From 9bfb1e1bc355c94cc3db07bd11c18f2cbe6c8a9c Mon Sep 17 00:00:00 2001 From: Senad Uka Date: Sun, 17 Nov 2019 12:55:40 +0100 Subject: [PATCH] Gunicorn fix --- Procfile | 1 + __pycache__/service.cpython-37.pyc | Bin 0 -> 719 bytes .../__pycache__/analyzer.cpython-37.pyc | Bin 1037 -> 1037 bytes parkingkonceptvenv/bin/gunicorn | 8 + .../gunicorn-20.0.0.dist-info/INSTALLER | 1 + .../gunicorn-20.0.0.dist-info/LICENSE | 23 + .../gunicorn-20.0.0.dist-info/METADATA | 116 + .../gunicorn-20.0.0.dist-info/RECORD | 76 + .../gunicorn-20.0.0.dist-info/WHEEL | 6 + .../entry_points.txt | 7 + .../gunicorn-20.0.0.dist-info/top_level.txt | 1 + .../site-packages/gunicorn/__init__.py | 8 + .../__pycache__/__init__.cpython-37.pyc | Bin 0 -> 368 bytes .../__pycache__/arbiter.cpython-37.pyc | Bin 0 -> 16639 bytes .../__pycache__/config.cpython-37.pyc | Bin 0 -> 61966 bytes .../gunicorn/__pycache__/debug.cpython-37.pyc | Bin 0 -> 1962 bytes .../__pycache__/errors.cpython-37.pyc | Bin 0 -> 1021 bytes .../__pycache__/glogging.cpython-37.pyc | Bin 0 -> 11094 bytes .../__pycache__/pidfile.cpython-37.pyc | Bin 0 -> 2238 bytes .../__pycache__/reloader.cpython-37.pyc | Bin 0 -> 3948 bytes .../gunicorn/__pycache__/sock.cpython-37.pyc | Bin 0 -> 6189 bytes .../__pycache__/socketfromfd.cpython-37.pyc | Bin 0 -> 2575 bytes .../__pycache__/systemd.cpython-37.pyc | Bin 0 -> 2409 bytes .../gunicorn/__pycache__/util.cpython-37.pyc | Bin 0 -> 11651 bytes .../site-packages/gunicorn/app/__init__.py | 4 + .../app/__pycache__/__init__.cpython-37.pyc | Bin 0 -> 146 bytes .../app/__pycache__/base.cpython-37.pyc | Bin 0 -> 6011 bytes .../app/__pycache__/pasterapp.cpython-37.pyc | Bin 0 -> 2112 bytes .../app/__pycache__/wsgiapp.cpython-37.pyc | Bin 0 -> 1897 bytes .../site-packages/gunicorn/app/base.py | 219 ++ .../site-packages/gunicorn/app/pasterapp.py | 75 + .../site-packages/gunicorn/app/wsgiapp.py | 62 + .../site-packages/gunicorn/arbiter.py | 646 ++++++ .../site-packages/gunicorn/config.py | 2012 +++++++++++++++++ .../python3.7/site-packages/gunicorn/debug.py | 69 + .../site-packages/gunicorn/errors.py | 29 + .../site-packages/gunicorn/glogging.py | 463 ++++ .../site-packages/gunicorn/http/__init__.py | 9 + .../http/__pycache__/__init__.cpython-37.pyc | Bin 0 -> 312 bytes .../http/__pycache__/body.cpython-37.pyc | Bin 0 -> 6394 bytes .../http/__pycache__/errors.cpython-37.pyc | Bin 0 -> 5842 bytes .../http/__pycache__/message.cpython-37.pyc | Bin 0 -> 8561 bytes .../http/__pycache__/parser.cpython-37.pyc | Bin 0 -> 1307 bytes .../http/__pycache__/unreader.cpython-37.pyc | Bin 0 -> 2368 bytes .../http/__pycache__/wsgi.cpython-37.pyc | Bin 0 -> 9023 bytes .../site-packages/gunicorn/http/body.py | 262 +++ .../site-packages/gunicorn/http/errors.py | 120 + .../site-packages/gunicorn/http/message.py | 362 +++ .../site-packages/gunicorn/http/parser.py | 51 + .../site-packages/gunicorn/http/unreader.py | 79 + .../site-packages/gunicorn/http/wsgi.py | 405 ++++ .../gunicorn/instrument/__init__.py | 0 .../__pycache__/__init__.cpython-37.pyc | Bin 0 -> 153 bytes .../__pycache__/statsd.cpython-37.pyc | Bin 0 -> 4479 bytes .../gunicorn/instrument/statsd.py | 129 ++ .../site-packages/gunicorn/pidfile.py | 86 + .../site-packages/gunicorn/reloader.py | 133 ++ .../python3.7/site-packages/gunicorn/sock.py | 213 ++ .../site-packages/gunicorn/socketfromfd.py | 96 + .../site-packages/gunicorn/systemd.py | 77 + .../python3.7/site-packages/gunicorn/util.py | 559 +++++ .../gunicorn/workers/__init__.py | 15 + .../__pycache__/__init__.cpython-37.pyc | Bin 0 -> 511 bytes .../workers/__pycache__/base.cpython-37.pyc | Bin 0 -> 7395 bytes .../__pycache__/base_async.cpython-37.pyc | Bin 0 -> 3810 bytes .../__pycache__/geventlet.cpython-37.pyc | Bin 0 -> 4488 bytes .../__pycache__/ggevent.cpython-37.pyc | Bin 0 -> 5975 bytes .../__pycache__/gthread.cpython-37.pyc | Bin 0 -> 8570 bytes .../__pycache__/gtornado.cpython-37.pyc | Bin 0 -> 4378 bytes .../workers/__pycache__/sync.cpython-37.pyc | Bin 0 -> 5055 bytes .../__pycache__/workertmp.cpython-37.pyc | Bin 0 -> 1663 bytes .../site-packages/gunicorn/workers/base.py | 267 +++ .../gunicorn/workers/base_async.py | 146 ++ .../gunicorn/workers/geventlet.py | 144 ++ .../site-packages/gunicorn/workers/ggevent.py | 205 ++ .../site-packages/gunicorn/workers/gthread.py | 359 +++ .../gunicorn/workers/gtornado.py | 169 ++ .../site-packages/gunicorn/workers/sync.py | 207 ++ .../gunicorn/workers/workertmp.py | 55 + requirements.txt | 1 + 80 files changed, 7975 insertions(+) create mode 100644 Procfile create mode 100644 __pycache__/service.cpython-37.pyc create mode 100755 parkingkonceptvenv/bin/gunicorn create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/INSTALLER create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/LICENSE create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/METADATA create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/RECORD create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/WHEEL create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/entry_points.txt create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/top_level.txt create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__init__.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/__init__.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/arbiter.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/config.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/debug.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/errors.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/glogging.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/pidfile.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/reloader.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/sock.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/socketfromfd.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/systemd.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/util.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__init__.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/__init__.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/base.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/pasterapp.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/wsgiapp.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/base.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/pasterapp.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/wsgiapp.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/arbiter.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/config.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/debug.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/errors.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/glogging.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__init__.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/__init__.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/body.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/errors.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/message.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/parser.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/unreader.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/wsgi.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/body.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/errors.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/message.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/parser.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/unreader.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/wsgi.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__init__.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__pycache__/__init__.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__pycache__/statsd.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/statsd.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/pidfile.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/reloader.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/sock.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/socketfromfd.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/systemd.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/util.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__init__.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/__init__.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/base.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/base_async.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/geventlet.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/ggevent.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/gthread.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/gtornado.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/sync.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/workertmp.cpython-37.pyc create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base_async.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/geventlet.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/ggevent.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gthread.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gtornado.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/sync.py create mode 100644 parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/workertmp.py diff --git a/Procfile b/Procfile new file mode 100644 index 0000000..a4763a2 --- /dev/null +++ b/Procfile @@ -0,0 +1 @@ +web: gunicorn service:app diff --git a/__pycache__/service.cpython-37.pyc b/__pycache__/service.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..646b9797a85731b6b984d04c3b382c51b42e2995 GIT binary patch literal 719 zcmYjP&5qMB5VoD){%p55*hk1^Bcv54v_c?pT#%NN1+u(}+h&{C!FCX>n$vRS9oi$0 z!_`+#yaHSpr{!m)8I311-+Z6r7iVW<1h#qd?fox|(070MV<9BZ!OaRniAr3f22+fE zP9P_g40%uoO-REgq7g;{i}(T41bRZ~NofkTA+4Ki&Lm76_tD2iNB#9OuI$>-^T-vp@;-%0o<&xK%t+T#Q2LFNwRU7$y(_gQd(dSb~w z*pVGRkUp^CKH3Eb{EqZtAK7>pJz$_6-Z*^eM&gqd(o{;)Sz8sh(}LY`Bc5Jmi4I^3 zO_#zl&sY2HbaE8L7F8{D0+#&TH* z^A+hCjQ_mKSE>>DiZ?26wYnFDHThQE)qI_w?q{uFptZRX`eRjy%XZ_=|6bvde*#cu z3IUN6PqFtI)^j+!l(B|alChg?N~4AUU7Em$qtY2~_*Tgiv>Egc68)TK&6o>#+YVZ3 oq*Z6d5jW7C93=b~&WDB18dY|+xQ3^Sj2AftI&)8oJRYU^Hx@#=r~m)} literal 0 HcmV?d00001 diff --git a/amazonservices/__pycache__/analyzer.cpython-37.pyc b/amazonservices/__pycache__/analyzer.cpython-37.pyc index 25c6d7de47a7b6b0ab7709473e1c7ecae2392086..7b8fd849093795a387c0451dce847e58c6696ba8 100644 GIT binary patch delta 19 YcmeC>=;h#Y;^pOH00M2(ja=;h#Y;^pOH00L(Hja +2009-2015 (c) Paul J. Davis + +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. diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/METADATA b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/METADATA new file mode 100644 index 0000000..dd92f5d --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/METADATA @@ -0,0 +1,116 @@ +Metadata-Version: 2.1 +Name: gunicorn +Version: 20.0.0 +Summary: WSGI HTTP Server for UNIX +Home-page: http://gunicorn.org +Author: Benoit Chesneau +Author-email: benoitc@e-engura.com +License: MIT +Platform: UNKNOWN +Classifier: Development Status :: 4 - Beta +Classifier: Environment :: Other Environment +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: POSIX +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Internet +Classifier: Topic :: Utilities +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Internet :: WWW/HTTP +Classifier: Topic :: Internet :: WWW/HTTP :: WSGI +Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server +Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content +Requires-Python: >=3.4 +Requires-Dist: setuptools (>=3.0) +Provides-Extra: eventlet +Requires-Dist: eventlet (>=0.9.7) ; extra == 'eventlet' +Provides-Extra: gevent +Requires-Dist: gevent (>=0.13) ; extra == 'gevent' +Provides-Extra: gthread +Provides-Extra: setproctitle +Requires-Dist: setproctitle ; extra == 'setproctitle' +Provides-Extra: tornado +Requires-Dist: tornado (>=0.2) ; extra == 'tornado' + +Gunicorn +-------- + +.. image:: https://img.shields.io/pypi/v/gunicorn.svg?style=flat + :alt: PyPI version + :target: https://pypi.python.org/pypi/gunicorn + +.. image:: https://img.shields.io/pypi/pyversions/gunicorn.svg + :alt: Supported Python versions + :target: https://pypi.python.org/pypi/gunicorn + +.. image:: https://travis-ci.org/benoitc/gunicorn.svg?branch=master + :alt: Build Status + :target: https://travis-ci.org/benoitc/gunicorn + +Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. It's a pre-fork +worker model ported from Ruby's Unicorn_ project. The Gunicorn server is broadly +compatible with various web frameworks, simply implemented, light on server +resource usage, and fairly speedy. + +Feel free to join us in `#gunicorn`_ on Freenode_. + +Documentation +------------- + +The documentation is hosted at http://docs.gunicorn.org. + +Installation +------------ + +Gunicorn requires **Python 3.x >= 3.4**. + +Install from PyPI:: + + $ pip install gunicorn + + +Usage +----- + +Basic usage:: + + $ gunicorn [OPTIONS] APP_MODULE + +Where ``APP_MODULE`` is of the pattern ``$(MODULE_NAME):$(VARIABLE_NAME)``. The +module name can be a full dotted path. The variable name refers to a WSGI +callable that should be found in the specified module. + +Example with test app:: + + $ cd examples + $ gunicorn --workers=2 test:app + + +Contributing +------------ + +See `our complete contributor's guide `_ for more details. + + +License +------- + +Gunicorn is released under the MIT License. See the LICENSE_ file for more +details. + +.. _Unicorn: https://bogomips.org/unicorn/ +.. _`#gunicorn`: https://webchat.freenode.net/?channels=gunicorn +.. _Freenode: https://freenode.net/ +.. _LICENSE: https://github.com/benoitc/gunicorn/blob/master/LICENSE + + diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/RECORD b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/RECORD new file mode 100644 index 0000000..61cccdc --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/RECORD @@ -0,0 +1,76 @@ +../../../bin/gunicorn,sha256=5qzXoIpEjWb9e0Tx1710URAtNYEiZfA_gBHXk4-ve-A,275 +gunicorn-20.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +gunicorn-20.0.0.dist-info/LICENSE,sha256=eJ_hG5Lhyr-890S1_MOSyb1cZ5hgOk6J-SW2M3mE0d8,1136 +gunicorn-20.0.0.dist-info/METADATA,sha256=9tN4kUp7jxW41FyRFmnIdaHSdP2IgIcBdNivMY_SL6U,3523 +gunicorn-20.0.0.dist-info/RECORD,, +gunicorn-20.0.0.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110 +gunicorn-20.0.0.dist-info/entry_points.txt,sha256=iKqKVTg4RzByDFxtGUiHcSAFATmYSYMO0f7S5RPLK6o,130 +gunicorn-20.0.0.dist-info/top_level.txt,sha256=cdMaa2yhxb8do-WioY9qRHUCfwf55YztjwQCncaInoE,9 +gunicorn/__init__.py,sha256=gy8O6y4wdf4Sn6dfPMPWP6Dp0-vN54xCpA-I_QILTr8,255 +gunicorn/__pycache__/__init__.cpython-37.pyc,, +gunicorn/__pycache__/arbiter.cpython-37.pyc,, +gunicorn/__pycache__/config.cpython-37.pyc,, +gunicorn/__pycache__/debug.cpython-37.pyc,, +gunicorn/__pycache__/errors.cpython-37.pyc,, +gunicorn/__pycache__/glogging.cpython-37.pyc,, +gunicorn/__pycache__/pidfile.cpython-37.pyc,, +gunicorn/__pycache__/reloader.cpython-37.pyc,, +gunicorn/__pycache__/sock.cpython-37.pyc,, +gunicorn/__pycache__/socketfromfd.cpython-37.pyc,, +gunicorn/__pycache__/systemd.cpython-37.pyc,, +gunicorn/__pycache__/util.cpython-37.pyc,, +gunicorn/app/__init__.py,sha256=GuqstqdkizeV4HRbd8aGMBn0Q8IDOyRU1wMMNqNe5GY,127 +gunicorn/app/__pycache__/__init__.cpython-37.pyc,, +gunicorn/app/__pycache__/base.cpython-37.pyc,, +gunicorn/app/__pycache__/pasterapp.cpython-37.pyc,, +gunicorn/app/__pycache__/wsgiapp.cpython-37.pyc,, +gunicorn/app/base.py,sha256=xRi7ULHpgnqVXH4Nf_9htDEIJMwvaDTz0PvO7bRsk-0,6570 +gunicorn/app/pasterapp.py,sha256=Bb0JwQNqZxmZ-gvvZUGWAEc9RX2BdhdhfhJ2a12Xafo,2038 +gunicorn/app/wsgiapp.py,sha256=2cq99svAzU8JFkC3-TfUsZIwOksnjZYwkuF4C1KxWwE,1671 +gunicorn/arbiter.py,sha256=wzrzKxGp1QD0Mz0TcxWiEmVKnNZgYX_5bNSJsv3zZlA,20222 +gunicorn/config.py,sha256=xLpSJcNIM8Dx12_2vq8yP0JtP3o3nR9udOxBBqy_Wvo,55606 +gunicorn/debug.py,sha256=UUw-eteLEm_OQ98D6K3XtDjx4Dya2H35zdiu8z7F7uc,2289 +gunicorn/errors.py,sha256=JlDBjag90gMiRwLHG3xzEJzDOntSl1iM32R277-U6j0,919 +gunicorn/glogging.py,sha256=dDFX0rchHQoG-R_v9QJiRl5fTr2grv4ALtYl_1vURQM,14943 +gunicorn/http/__init__.py,sha256=b4TF3x5F0VYOPTOeNYwRGR1EYHBaPMhZRMoNeuD5-n0,277 +gunicorn/http/__pycache__/__init__.cpython-37.pyc,, +gunicorn/http/__pycache__/body.cpython-37.pyc,, +gunicorn/http/__pycache__/errors.cpython-37.pyc,, +gunicorn/http/__pycache__/message.cpython-37.pyc,, +gunicorn/http/__pycache__/parser.cpython-37.pyc,, +gunicorn/http/__pycache__/unreader.cpython-37.pyc,, +gunicorn/http/__pycache__/wsgi.cpython-37.pyc,, +gunicorn/http/body.py,sha256=X1vbGcTSM3-2UI2ubtavuTS4yOd0fpTyfeFaQZ_x92o,7297 +gunicorn/http/errors.py,sha256=sNjF2lm4m2qyZ9l95_U33FRxPXpxXzjnZyYqWS-hxd4,2850 +gunicorn/http/message.py,sha256=2ENXbsAY6X4Tnb7CxQxYbcpfktn5iPwgire9JCG383Q,12211 +gunicorn/http/parser.py,sha256=IRMvp0veP4wL8Z4vgNV72CPydCNPdNNIy9u-DlDvvSo,1294 +gunicorn/http/unreader.py,sha256=pXVde3fNCUIO2FLOSJ0iNtEEpA0m8GH6_R2Sl-cB-J8,1943 +gunicorn/http/wsgi.py,sha256=0KyC1pQWIc_xKX-kFOP6rG-R_NQSj7fBQM3NlLlli2w,12704 +gunicorn/instrument/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +gunicorn/instrument/__pycache__/__init__.cpython-37.pyc,, +gunicorn/instrument/__pycache__/statsd.cpython-37.pyc,, +gunicorn/instrument/statsd.py,sha256=la-bzhQXHqbZyU38p1F-vxym7B_VIWZ9z-LKf7g8oGs,4632 +gunicorn/pidfile.py,sha256=_69tsfF1aHklrMrJe2sHERovMduRByVTv99my7yQ874,2357 +gunicorn/reloader.py,sha256=L0V8-e3G_fikeSv05nXGsDg8IwlzBVGQlMqJQpCuh0w,3845 +gunicorn/sock.py,sha256=lry2qvRs23Kcnnr8X1F_y3-ELbHGeI9TLY9Xn8Tb2jQ,6108 +gunicorn/socketfromfd.py,sha256=1vxDfprdDcyfbxRUowj9Jh9X1zXu1OAqDYU0QFZZcDw,2926 +gunicorn/systemd.py,sha256=k2qJb6wAEv9Vk-k8zuTr9OyHJW6K2GkqWrSNoR3zTrs,2511 +gunicorn/util.py,sha256=zOO1ihrgFXJeZXf3Br7jhTwcHFeEs1BvaFOLZsWrPZ4,15710 +gunicorn/workers/__init__.py,sha256=Gv_JJXKofikyiPbRAUQ0IXIchKxgt0Gu-8y-nYRN9vY,594 +gunicorn/workers/__pycache__/__init__.cpython-37.pyc,, +gunicorn/workers/__pycache__/base.cpython-37.pyc,, +gunicorn/workers/__pycache__/base_async.cpython-37.pyc,, +gunicorn/workers/__pycache__/geventlet.cpython-37.pyc,, +gunicorn/workers/__pycache__/ggevent.cpython-37.pyc,, +gunicorn/workers/__pycache__/gthread.cpython-37.pyc,, +gunicorn/workers/__pycache__/gtornado.cpython-37.pyc,, +gunicorn/workers/__pycache__/sync.cpython-37.pyc,, +gunicorn/workers/__pycache__/workertmp.cpython-37.pyc,, +gunicorn/workers/base.py,sha256=IpoZSjEDL_CV6FtBtlhb3xLsrbdfsIcYDgOe9adAwSc,9014 +gunicorn/workers/base_async.py,sha256=e7rx-vyEp4FxshTayWCav8PGJoxCUCvQKRNeSJT9Org,5528 +gunicorn/workers/geventlet.py,sha256=Mv1dPR_wceMp7yHhqFqRzkpyveSVrJ88978XSfk3jrM,4096 +gunicorn/workers/ggevent.py,sha256=zK6yOdFwOPwPyXH9kF1IMYODDpK9Rs9aWYojiyCF1Ck,6099 +gunicorn/workers/gthread.py,sha256=R09oCLImmRy6hzaRXAOWlj8fJ1zey6cWfWx-Fl2NabA,11886 +gunicorn/workers/gtornado.py,sha256=TjD9PZqs3gCit-BLiNlw5_kMX7DG0gnVK3hWJpAaWOc,5902 +gunicorn/workers/sync.py,sha256=SlnJVI3vC2k8j7yj0JDKOFLcHR07Dq1Hv6JrtXZqaJQ,7124 +gunicorn/workers/workertmp.py,sha256=etRs6hl0F9X3VV3QJrS3GnmY1RnOeo9D9EMRKRzVS1g,1639 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/WHEEL b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/WHEEL new file mode 100644 index 0000000..8b701e9 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.33.6) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/entry_points.txt b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/entry_points.txt new file mode 100644 index 0000000..f70a5be --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/entry_points.txt @@ -0,0 +1,7 @@ + + [console_scripts] + gunicorn=gunicorn.app.wsgiapp:run + + [paste.server_runner] + main=gunicorn.app.pasterapp:serve + \ No newline at end of file diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/top_level.txt b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/top_level.txt new file mode 100644 index 0000000..8f22dcc --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn-20.0.0.dist-info/top_level.txt @@ -0,0 +1 @@ +gunicorn diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__init__.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__init__.py new file mode 100644 index 0000000..7b38ab0 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__init__.py @@ -0,0 +1,8 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +version_info = (20, 0, 0) +__version__ = ".".join([str(v) for v in version_info]) +SERVER_SOFTWARE = "gunicorn/%s" % __version__ diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/__init__.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56f169252b637eb43a966c562d5d1b6bf2bbf6f6 GIT binary patch literal 368 zcmYLExlY4C5S>|@5ORnn;tQZ~kpmi| literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/arbiter.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/arbiter.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ed0448b5e40fadc964cfead790f86ecf8e36160 GIT binary patch literal 16639 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 Yz|YPMxx7a97cw;2ooNZpCHl+#e+X1+W&i*H literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/config.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/config.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f0958677384d13e9a30db45ee97decc413d096a GIT binary patch literal 61966 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%0A2HB4fgjD?79*{jx1T+g&aha zl+a79u*7);2AlxXfVK~I3dE}6{xVqSVx%4hxVv&Ad`Ec;$OXtjUMsVgCbE| zro02+OE|;OZEU{ANkfyf!GR*Ef#T>F1n1^Aps;x)Y>!0Em)2MdL@xAdR>Ep~CPs3N zAjTEP%QlQ39zsGD89>qmZ0Ek4gyj(rJ=Cb1Lbc>kVF(B^5mMTu6dJwfOzNHaKVs~b z!2MdO!1n#f^uAmOv<@9%-5#k8mip!nHH^9VN395FxKx*7UJJq@t+|win|8~Sb{qBL zu8Ax0?h&m^PGD@~#IOZXyHV}c;#zcHTX<&w-?Bk6e)<6pwkmu>fuN1?5j10)QWb-R*z;BQ|LGwVgVsjxhWe{c` ziLoPiYyp8wj@g&+xyl+a^%DGf++#~?=Ju%0)*ZuRV;qBDQ&7pyqAfrCkc8;4eg`R| znAb8duZK>iaTvOez)}+ZE@D1#qDE)o;Je%?Jt@WK&i_Mtlm;S2e0XSi#EtL=gpt}A^IQEHiV;`o|V`8S{bRHh>CI`6B504 z8Z=QkK(!bp)z?(nsz^wXbHw|_8?)df$Bd)>UX9wI>KTPe)8%{s>)^kgMW+!=*4|ch z@?~}AMWfTHNGfP2@%dAIsv9o!ABg2U9ef@Y&%(ztyDn5A0V&e9W_PU$%}gg6JyRN> z=W4Y@SH4|VLi_TMzx*4 zbK#ahr2%VM!|<*JZprr`LZOgwER12WfiJ?>G1WZ4Q^syIzJL~0{Ryb*Hpgr;4^98H^eh!4)O3XPnCN8+4NY{Z*quo81pl{lfzIPvHAd$oAbU= zl)HD`tS7RGY+5mI$7elzp*krs3!9yQybincI%Zs*!|F{w;4Mg;#d)Jq|;{v7m(t{S8~p z9O8Cn_z9F7-e88Ax8pP1LA?`^;F?(|sPwH}Y@6Lb#KJ5I(Zvma(Tfd;cS0}aCJMB# z=O^*jv!N;OGtK7wRzDpzyN`UqJ6Kg=T!O*KjUq_eRv5 z>m}_+;#k0b#H@ploBa1N@f`McCVm{{>K;Fra>PMg)zNc zZ(H{~WW8OXO+_vFcViSUg%IG)tsT&45N`hq+r);Dz$PY(7M^g3fpRMmh>^@@6!Uf*F*-e@sDsA~egGYI92=(4^^b(GVZYz1 z`LMJ!`uT03fO7?cwaq{dkmSb3r|BhtyLVq4o8GQa_t!A}9RGHve-hv9gLYqxlcu6Oja>( z$1#Q?<0xWTYmt!w^N>SzH?hNgz%C!qt{W_q1+00XmD4(`Ow)!3!j z^|&3s8o!jlUve&SAa)}j*A}0|cq4rXC-mHbR5J;ehh|zF{+k(nDonA0frOSU{sr#a zHHv33?5~7y+75(jo{&&;^0ISG8*LhG7tO-9Hau(1Dq2?XC*;mzYb_>SqxQ*ica}bzP5*PmCFZ#6s#Yu`qGv5h;vLKO#u;l?V zCb#WO$U!yPj$nuCo^?ITwRfyYA7O7!)|<7D;3IqmGnOMzUW_5kjB2~+BautnETEpJ zTqN#@$y7p}$~RoSF99O-oGd}Qy>JVSN5_mDrF#_W5d1?(#@4?|^E`Z2Ac{+Yxw2wl z7}=9O;zRZbT3V?D7FmQTnlV99Ux&EF`PmK%+bEadJhntbCz z#H9`=>vUiTwdGrW7pg+uIO*k@*y1-N_W zc^`%5cT;-x?P*S%_$miXi^JK@9L}TMEgW`mZV2<2gto+-mKj7k_89(dK1}4U3C3K* zMPf?idm%htS)&J(q$9j6;Dsq=c$G5RC%MRN6>lDl?=hl3!~MZRG`VM zJ|<=y;#I+o2^F$Z4;8#@lO=bROsL|d(LLl$8|-pXTX z$0XN>ORj#U9=L9d>Tn4{G`#Lmlu-%HsTokG1pZF?=sTpB4Juw zCwwl0-C3`wMGR>?aw#Mg^LA*s*bUdw=+SUcr+Tvw2diep5yb$S-f;b9Kc|-$c>{sD% z6j0&72k$P4*;~TbWdFq060&E?2;Z z7@iuHLpnqFXzXCsA1O5hf3%)x7*{$Tf z2*Cvb`V52WN-OAETLF!3p8IiBFHRme6Nr~3(tzh_&J(qoKMFomjHi1oG)NqIkj>M! zwgUHDfREZDqxBG6TOV=$Y0^7!UX<9#yZr&`{%_&FxCBb%tmj3U+Z1zlghmNzhE3XS zc9QIJFT>UJ32}}11Th(3bQ@zFE?mzjFPqiYLZ(3)Xhwz)I?g`1_=*b-^1(;k!le2^ zH}pc=8fHQCdx2T!@aW`pVf@1Q=oZjg224H}0j;EBPBgS`o^uZm4Ff7}Gg~Sa2prlR2m}2PHF$9!)piMwId@v~<43Dz`+SP1IqDpb;ES z5A=eUxe#G|3tz;Wb_JdJfek>%yqg7Gt2O|6K!a}oNbMZ7M0Wv4%r8`jwFcF^)vgs7 zsYo6dV0bX}S+Bs`crtO&&mXK+861bIm-(E+#qg?xuz+yjV7W^oHTtj78$^HR(WCya z8^8fr15j@W;8g(ea~lAddC>sgrn;4qQ%D`d`|FE)FqD z34|`3SA~TFm3SvQ;2xr5J#%!{)6T3lw7hIhQOsj(I%uvu`(yQAczS4RLeuOTPh+F= zMM$RjR2(`4Q35?M{W8Nv3cM7IK;*ok`zgK-4@%b__QLF}uCC^4t3`KNg6tp!zjGzG zys&%>{JtwX7GW796Mk=uAQLTj>%_6*^3p{tTG7tY8Y&pacQs`4b#< zD$h#b0K!b*Bw{SbCt>x>Eb?<>l(=TRiPl}P&ht#w8I1`ewUV6L2|hB`Iv4Y&TV5z7K`}TSB;;GQyIYPjm z3Ebx-@=wNV4uvs9$l5Xvy5hvCvE8*B>h80=(~{QUtmTJbKmE}0J9zmWUiR=Z$P48|br&xm9rD0C|ZudPav9^gyrLDtpF41R*CnW@c^DyrM~ zM2;Z6#Jf-MBHZvtcqfvpi2SnZzQ|_+n=kQBEKtA1J2BdSm3Lp~G5ib%s;otJ^ z-|_Oty!?A!{)Cr5<>f!}@@KsKIWPZ-m%rfUTfF=wFMq{LOn|{likCDmoxF7O(!amPoZ^Lhd=f`SqNGUB3<>|B7>GcQ!^;t6IfyH#J{8aE$;6mh#e3pCiBvq3?CQ>T^u0HBs_&M*q26S+ zFPq7BXAflguREK{cH;M7wl}*Qf4z9pkzrSx6^82Lp9z4HYp7i$JFK_hX%D=m$M31C)q3piCE?oEE gDgW`kJyKrZ??Y-Ip5Kl#J!r*3>2Cbj(|7Q{0T^;$Y5)KL literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/debug.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/debug.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46f66cc52948c80ff9d9d02ff53b89b182c11b06 GIT binary patch literal 1962 zcmZuy&2Jnv6u0MlW;Y?EC883bkx&pT+N2;32nwo7X;mZwY72pFqtWcxyF1y*%+&TY z&1&}4aOV%;uzTdrpTPx*ldoLbBiCNwJ#W%PsP_6jkNy1odww5#V`U{G(Ej-7&%J*F zLjJ~&)8@eBIt=*`2qS&MD6%Zt`yuPFklDwyAF+rz$E4q3);-eePQSZ9<}u@gW)vS(tSNY$Ri#SvQpSzSi(KVg z#%amoVN+%*uV8&xiFm-3;vzB!M|nAlZ#QM0RifN_4w%V~c4W;Dwbzu$r}o3$4>H_1 zZ8l76(b{4>G!F~ud z8d@75^AjnpA4yC0JB&;M`Frc(eBvQe)ny@kJFP!oS&*TB$)gUdT4tUArVXnqH#LX%*M&s-_B z4csKwl7uJ;&kolWNpcCkV~IfsRsL`Xfz*~cumg3?mPZg} z63R2yK7+hxoz=Pj+lsb)216R-oD8Nfn+-E#Bfciu$e@C}wC>7Xeo#H;v4a1PbLL@& zfOi4h;3&r0e+tbK+n`2VMe?dw$J=heSR%2(k+*tX?I#JVvLsm^Mz3f~aDjCe_e>mN yG91+KcH(VZ_Nu`?I>+P%qCCUx{ zfp6enxN!BA6TiTTnYC(1YA=j5v-7+&vu|d6HX02W%Fh?S-hcNQ`%U0R0(4GM?MpOo zm}HWFLsjgnKj(-&=_B@)huB9P$PVI;!-4ExvbdLGW+Pa?uJ;5T#pYbHxhH$B4xjsV z{=Ci%tHIkOFE15*Qt*dkLQ3f*bb6@gsCJBI%ePFht%nv%;Zm zg2uXe8eLqc%9L55BSO?4hB~WswT8!_JX)6h|2G2-S@w zf_PpmdZMiOlpeN_3PMlV@q-+PKXZ_L0J!Txpb#ceoOs j;i5)oiB-*H+>EP!i>W1`*t?2W;c>m%lV(xl{y6vtT)x#1 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/glogging.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/glogging.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac0039fd08b6fb95fe015b2f143f1e7b093ab271 GIT binary patch literal 11094 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 G(0dMBegb3w literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/reloader.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/reloader.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06bd1529b61fee564af34339231a10416d5fabb1 GIT binary patch literal 3948 zcmaJ^TW{OQ8J!tkM9Q)vD_QTQX{z2*XtC>LQ?#3I(_nXFdl4X!TgPY;76F&h(6(fX zl801c3o=mD0Tw8FLErlzzbw!{(O=M)_K~lB%3s*0o^MFXv6C)^nfW+3&UZU!^!egq zmErlm2y0ttj6f;|j6Yf>M zVA7E03ntCb>O04V=Ss_~hDLv3R+IJ#SARLYj8&CraZvZ_JpaN4uOS_;`jEw!OcpNf zRn?z3qu*l|i$^T1s;{xHE34SITI}158|Ygo`Yz&2P0age*o;N!dY8gWp&K@3?eB*7 zmgEmud+{aoVx384bojgO@X3$5^jbbMxb2h_h7|2j{UUKZyEqA5XC`xh*LduTWjGsWkDVqt&PdI0(G3BGn zQXKOs^Uc(n*(VtFD^r2mnHs2F$?zScv-JQs2+qBurO>a4?KB z17cS5!-G@>{&p`4lgv$bRT#)#ypvg*_lDiQZ0Xf;KcX%dd!?az7DN!cK@>d=x_fOi zGm|jd&K6$X&zaA3<`X$q`Q0c;65m&(^*0}1O9!KCqu%JlUYw-Z@WVm(y4)X+KDxFu zj(gpqicbYqm~UltsBElmq9ip`j92liqu6}1R9bnZ)VwQb4jyV(ksS$ z4}FPtHh1{s?fLo6&gxQ3&~xULpP)l>DPABbQr;IcB;9-(g@~xY_K)x!LFNc|BnJ$A$o zet!@nbJ+=7Wlx?SiNgljbqWCN8%G9UY}sU~2^jk%hq3349LT2RNX$Air-05qM|sF= zJ{7mveq+A@+1xW#gIrDZ%%-^`0EKS+Cn zFsp1lSW{}KG6Tx1I!!b6fR#jHI8uw~XVBk9wE^TssPIDQ`! z6S5`aCj44QX`ptHq7Hs0ijDV4ZEjjDLbNKv!A{$um?KXCwyM6LyBBiJ_xHy^l#gf( zP;X;_R#IJqlr0tj(+#7j02zJ0HdhyECgrE13|m4;h}0ZjcO28H>E89sihA+*pv|+& z-FTSxwhy=7%mgu(mP`QpGW(XU?a!HRD@E%Rty{F!qFwl$c{N$p3?iiQ!u1xVDJ?KZ zUD~pO_JVYzi?*Q|WC{LU$SxFTDy`P(lD+7m45C8s$vUbxafs#$BQ=ka`M#Cfx~&{6 zPXQ=T>PO%ZM3JFm=z0-DqO;X@6-9Y&?g~j1EQ)NGS-$M4ME#6p$A2EA-Q7@WpR`RK zI;uf)38}&IbGj+LK_|{#LdbLo2ziIh zF!pTq9%Th&_)7QLlK)v~@Hb}QQPNxIjp)Gr<{(J++K&1Ow#>{?knUy`=&IrVWAv$; zG~g13Yqhg#_$-W(Tv(>w!Wd|SSVHHF`XxzP+f$V(av!4PaKmd*)f7!WxpH3JZ{dl# z(k*QC|9B!br~LR0Y(O5=Y_I}Bv%%H#Y(RvQnlnptf_(xTm8_sqzN6m7(so4=#c5M1 zBCK59?~rtvs+kY0Q5;-pYw{)Tf;&Cv?1h2_Z*&WEDSXA;Ku1mNh|(J|Q?_ zE|0bS=0kR{f_E{qG&{5?J~h^_@85(Z-eo!u?II6v7I|nOCe<(SrI!@zu=s5>Y95G+ zu8rzfs6021!<{hJd0OTnMPO#>u{|m1lOX| zX*bn%OjjRKbpusa>E*DQx!oaM>Ebl;+`AqB&gR-@TWeZeUAwmiv5wwc^dGF$r;gyD0OAO#LZJLcCXkJz$yuo8!t)Ic4c(oile#;ujqnbZ<=QYQ_J6 zD;8#p&Sd@ZaNHVN!r`S3{e?sSC--4%f*)`8OG&kHekT`Gc$%-+)fLNph93%fyrKOCBcGiMY9>Gn_! zvMQ{j(&TwB-Sry9@Jb+q5&oIvROBs{-SZgK=TYPo?XS!pKJACy)N77ZxDCn*rC(as zYm|~7#yh?E%ym&4LSOQoTe-V#6D2035Z!EwpQswm_f1~Iy{D%8>fAO=ap^|Gt{DQo F{{#6eaOwa6 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/sock.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/sock.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ef8af0325b759207a1d2e44225098c3a6144bda GIT binary patch literal 6189 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 N&6cvI^IpMU{2x! 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 KRJB>B_Srx0hR~7# literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/util.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/__pycache__/util.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef456fd403973388d3b72bfadbebcc244baaa7fd GIT binary patch literal 11651 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 pI7e;EHf@Un4(OYKuDG`G+>^e*wGjq$dCX literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__init__.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__init__.py new file mode 100644 index 0000000..87f0611 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__init__.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/__init__.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c48ed82337ae317bfa388c4d2d180f75aabe7f8a GIT binary patch literal 146 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 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/wsgiapp.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/__pycache__/wsgiapp.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..298e02a76b3d03d4ea38dabc4fba93897fffb5d2 GIT binary patch literal 1897 zcmZ`(&2QX96rZujUhl?9nWo)~ zm2>G<;>7>3%Z>kq3s+w`^%?#h5NSmpdF`sFgrB-J9HYJBdSi*izgdMSo>9<5nIM0di zL~YT2Y{>5-XF@=No{(Q$c(~P+`DNrZ5GAoy~Fh)&hYo+W2R4?Z=bD2WuaMXey2tObg~cnCdrJ zYU6^)3e}>~mtbgRUa+Z!_cMBF)z;J&=8OuqM=ovs)~f9pRbN+*uxk4?GNI3CO)lEg zj)FDM`d zC+!Ra#nU2=lRW03cIQj_j>Olods}*WQF()6lnZ}bM1x?IR=ku&$nzkJ{5A;AWyW5= z@PaG%ds!hyY2>Lg3X?$+iC%ZJvC2SIQPb9&1a67GYm7oQtPHAQ(+bX&CM*SktQtG| zDN&V@7`Mg@2XSMnr~Y;Fm&c=be2~%g13q(bxm3fLw}x7^Z;~Q24S_vLl4HoVdR~iEvw<|%nOSw3v%J5NgjD}l;@Fz zMj^d480Fy*x`}tVC>`%6a02+>o+|Ke|*Qf@e^~$&5bq&HQRE_ib XJl0=ejwoy)4t5Rdn%CcV+7A62^Ebye literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/base.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/base.py new file mode 100644 index 0000000..470b40a --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/base.py @@ -0,0 +1,219 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. +import importlib.machinery +import os +import sys +import traceback +import types + +from gunicorn import util +from gunicorn.arbiter import Arbiter +from gunicorn.config import Config, get_default_config_file +from gunicorn import debug + + +class BaseApplication(object): + """ + An application interface for configuring and loading + the various necessities for any given web framework. + """ + def __init__(self, usage=None, prog=None): + self.usage = usage + self.cfg = None + self.callable = None + self.prog = prog + self.logger = None + self.do_load_config() + + def do_load_config(self): + """ + Loads the configuration + """ + try: + self.load_default_config() + self.load_config() + except Exception as e: + print("\nError: %s" % str(e), file=sys.stderr) + sys.stderr.flush() + sys.exit(1) + + def load_default_config(self): + # init configuration + self.cfg = Config(self.usage, prog=self.prog) + + def init(self, parser, opts, args): + raise NotImplementedError + + def load(self): + raise NotImplementedError + + def load_config(self): + """ + This method is used to load the configuration from one or several input(s). + Custom Command line, configuration file. + You have to override this method in your class. + """ + raise NotImplementedError + + def reload(self): + self.do_load_config() + if self.cfg.spew: + debug.spew() + + def wsgi(self): + if self.callable is None: + self.callable = self.load() + return self.callable + + def run(self): + try: + Arbiter(self).run() + except RuntimeError as e: + print("\nError: %s\n" % e, file=sys.stderr) + sys.stderr.flush() + sys.exit(1) + + +class Application(BaseApplication): + + # 'init' and 'load' methods are implemented by WSGIApplication. + # pylint: disable=abstract-method + + def chdir(self): + # chdir to the configured path before loading, + # default is the current dir + os.chdir(self.cfg.chdir) + + # add the path to sys.path + if self.cfg.chdir not in sys.path: + sys.path.insert(0, self.cfg.chdir) + + def get_config_from_filename(self, filename): + + if not os.path.exists(filename): + raise RuntimeError("%r doesn't exist" % filename) + + try: + module_name = '__config__' + mod = types.ModuleType(module_name) + loader = importlib.machinery.SourceFileLoader(module_name, filename) + loader.exec_module(mod) + except Exception: + print("Failed to read config file: %s" % filename, file=sys.stderr) + traceback.print_exc() + sys.stderr.flush() + sys.exit(1) + + return vars(mod) + + def get_config_from_module_name(self, module_name): + return vars(importlib.import_module(module_name)) + + def load_config_from_module_name_or_filename(self, location): + """ + Loads the configuration file: the file is a python file, otherwise raise an RuntimeError + Exception or stop the process if the configuration file contains a syntax error. + """ + + if location.startswith("python:"): + module_name = location[len("python:"):] + cfg = self.get_config_from_module_name(module_name) + else: + if location.startswith("file:"): + filename = location[len("file:"):] + else: + filename = location + cfg = self.get_config_from_filename(filename) + + for k, v in cfg.items(): + # Ignore unknown names + if k not in self.cfg.settings: + continue + try: + self.cfg.set(k.lower(), v) + except: + print("Invalid value for %s: %s\n" % (k, v), file=sys.stderr) + sys.stderr.flush() + raise + + return cfg + + def load_config_from_file(self, filename): + return self.load_config_from_module_name_or_filename(location=filename) + + def load_config(self): + # parse console args + parser = self.cfg.parser() + args = parser.parse_args() + + # optional settings from apps + cfg = self.init(parser, args, args.args) + + # set up import paths and follow symlinks + self.chdir() + + # Load up the any app specific configuration + if cfg: + for k, v in cfg.items(): + self.cfg.set(k.lower(), v) + + env_args = parser.parse_args(self.cfg.get_cmd_args_from_env()) + + if args.config: + self.load_config_from_file(args.config) + elif env_args.config: + self.load_config_from_file(env_args.config) + else: + default_config = get_default_config_file() + if default_config is not None: + self.load_config_from_file(default_config) + + # Load up environment configuration + for k, v in vars(env_args).items(): + if v is None: + continue + if k == "args": + continue + self.cfg.set(k.lower(), v) + + # Lastly, update the configuration with any command line settings. + for k, v in vars(args).items(): + if v is None: + continue + if k == "args": + continue + self.cfg.set(k.lower(), v) + + # current directory might be changed by the config now + # set up import paths and follow symlinks + self.chdir() + + def run(self): + if self.cfg.check_config: + try: + self.load() + except: + msg = "\nError while loading the application:\n" + print(msg, file=sys.stderr) + traceback.print_exc() + sys.stderr.flush() + sys.exit(1) + sys.exit(0) + + if self.cfg.spew: + debug.spew() + + if self.cfg.daemon: + util.daemonize(self.cfg.enable_stdio_inheritance) + + # set python paths + if self.cfg.pythonpath: + paths = self.cfg.pythonpath.split(",") + for path in paths: + pythonpath = os.path.abspath(path) + if pythonpath not in sys.path: + sys.path.insert(0, pythonpath) + + super().run() diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/pasterapp.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/pasterapp.py new file mode 100644 index 0000000..4c9fc7d --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/pasterapp.py @@ -0,0 +1,75 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import configparser +import os + +from paste.deploy import loadapp + +from gunicorn.app.wsgiapp import WSGIApplication +from gunicorn.config import get_default_config_file + + +def get_wsgi_app(config_uri, name=None, defaults=None): + if ':' not in config_uri: + config_uri = "config:%s" % config_uri + + return loadapp( + config_uri, + name=name, + relative_to=os.getcwd(), + global_conf=defaults, + ) + + +def has_logging_config(config_file): + parser = configparser.ConfigParser() + parser.read([config_file]) + return parser.has_section('loggers') + + +def serve(app, global_conf, **local_conf): + """\ + A Paste Deployment server runner. + + Example configuration: + + [server:main] + use = egg:gunicorn#main + host = 127.0.0.1 + port = 5000 + """ + config_file = global_conf['__file__'] + gunicorn_config_file = local_conf.pop('config', None) + + host = local_conf.pop('host', '') + port = local_conf.pop('port', '') + if host and port: + local_conf['bind'] = '%s:%s' % (host, port) + elif host: + local_conf['bind'] = host.split(',') + + class PasterServerApplication(WSGIApplication): + def load_config(self): + self.cfg.set("default_proc_name", config_file) + + if has_logging_config(config_file): + self.cfg.set("logconfig", config_file) + + if gunicorn_config_file: + self.load_config_from_file(gunicorn_config_file) + else: + default_gunicorn_config_file = get_default_config_file() + if default_gunicorn_config_file is not None: + self.load_config_from_file(default_gunicorn_config_file) + + for k, v in local_conf.items(): + if v is not None: + self.cfg.set(k.lower(), v) + + def load(self): + return app + + PasterServerApplication().run() diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/wsgiapp.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/wsgiapp.py new file mode 100644 index 0000000..c8501e5 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/app/wsgiapp.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import os + +from gunicorn.errors import ConfigError +from gunicorn.app.base import Application +from gunicorn import util + + +class WSGIApplication(Application): + def init(self, parser, opts, args): + if opts.paste: + from .pasterapp import has_logging_config + + config_uri = os.path.abspath(opts.paste) + config_file = config_uri.split('#')[0] + + if not os.path.exists(config_file): + raise ConfigError("%r not found" % config_file) + + self.cfg.set("default_proc_name", config_file) + self.app_uri = config_uri + + if has_logging_config(config_file): + self.cfg.set("logconfig", config_file) + + return + + if not args: + parser.error("No application module specified.") + + self.cfg.set("default_proc_name", args[0]) + self.app_uri = args[0] + + def load_wsgiapp(self): + return util.import_app(self.app_uri) + + def load_pasteapp(self): + from .pasterapp import get_wsgi_app + return get_wsgi_app(self.app_uri, defaults=self.cfg.paste_global_conf) + + def load(self): + if self.cfg.paste is not None: + return self.load_pasteapp() + else: + return self.load_wsgiapp() + + +def run(): + """\ + The ``gunicorn`` command line runner for launching Gunicorn with + generic WSGI applications. + """ + from gunicorn.app.wsgiapp import WSGIApplication + WSGIApplication("%(prog)s [OPTIONS] [APP_MODULE]").run() + + +if __name__ == '__main__': + run() diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/arbiter.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/arbiter.py new file mode 100644 index 0000000..bca671d --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/arbiter.py @@ -0,0 +1,646 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. +import errno +import os +import random +import select +import signal +import sys +import time +import traceback + +from gunicorn.errors import HaltServer, AppImportError +from gunicorn.pidfile import Pidfile +from gunicorn import sock, systemd, util + +from gunicorn import __version__, SERVER_SOFTWARE + + +class Arbiter(object): + """ + Arbiter maintain the workers processes alive. It launches or + kills them if needed. It also manages application reloading + via SIGHUP/USR2. + """ + + # A flag indicating if a worker failed to + # to boot. If a worker process exist with + # this error code, the arbiter will terminate. + WORKER_BOOT_ERROR = 3 + + # A flag indicating if an application failed to be loaded + APP_LOAD_ERROR = 4 + + START_CTX = {} + + LISTENERS = [] + WORKERS = {} + PIPE = [] + + # I love dynamic languages + SIG_QUEUE = [] + SIGNALS = [getattr(signal, "SIG%s" % x) + for x in "HUP QUIT INT TERM TTIN TTOU USR1 USR2 WINCH".split()] + SIG_NAMES = dict( + (getattr(signal, name), name[3:].lower()) for name in dir(signal) + if name[:3] == "SIG" and name[3] != "_" + ) + + def __init__(self, app): + os.environ["SERVER_SOFTWARE"] = SERVER_SOFTWARE + + self._num_workers = None + self._last_logged_active_worker_count = None + self.log = None + + self.setup(app) + + self.pidfile = None + self.systemd = False + self.worker_age = 0 + self.reexec_pid = 0 + self.master_pid = 0 + self.master_name = "Master" + + cwd = util.getcwd() + + args = sys.argv[:] + args.insert(0, sys.executable) + + # init start context + self.START_CTX = { + "args": args, + "cwd": cwd, + 0: sys.executable + } + + def _get_num_workers(self): + return self._num_workers + + def _set_num_workers(self, value): + old_value = self._num_workers + self._num_workers = value + self.cfg.nworkers_changed(self, value, old_value) + num_workers = property(_get_num_workers, _set_num_workers) + + def setup(self, app): + self.app = app + self.cfg = app.cfg + + if self.log is None: + self.log = self.cfg.logger_class(app.cfg) + + # reopen files + if 'GUNICORN_FD' in os.environ: + self.log.reopen_files() + + self.worker_class = self.cfg.worker_class + self.address = self.cfg.address + self.num_workers = self.cfg.workers + self.timeout = self.cfg.timeout + self.proc_name = self.cfg.proc_name + + self.log.debug('Current configuration:\n{0}'.format( + '\n'.join( + ' {0}: {1}'.format(config, value.value) + for config, value + in sorted(self.cfg.settings.items(), + key=lambda setting: setting[1])))) + + # set enviroment' variables + if self.cfg.env: + for k, v in self.cfg.env.items(): + os.environ[k] = v + + if self.cfg.preload_app: + self.app.wsgi() + + def start(self): + """\ + Initialize the arbiter. Start listening and set pidfile if needed. + """ + self.log.info("Starting gunicorn %s", __version__) + + if 'GUNICORN_PID' in os.environ: + self.master_pid = int(os.environ.get('GUNICORN_PID')) + self.proc_name = self.proc_name + ".2" + self.master_name = "Master.2" + + self.pid = os.getpid() + if self.cfg.pidfile is not None: + pidname = self.cfg.pidfile + if self.master_pid != 0: + pidname += ".2" + self.pidfile = Pidfile(pidname) + self.pidfile.create(self.pid) + self.cfg.on_starting(self) + + self.init_signals() + + if not self.LISTENERS: + fds = None + listen_fds = systemd.listen_fds() + if listen_fds: + self.systemd = True + fds = range(systemd.SD_LISTEN_FDS_START, + systemd.SD_LISTEN_FDS_START + listen_fds) + + elif self.master_pid: + fds = [] + for fd in os.environ.pop('GUNICORN_FD').split(','): + fds.append(int(fd)) + + self.LISTENERS = sock.create_sockets(self.cfg, self.log, fds) + + listeners_str = ",".join([str(l) for l in self.LISTENERS]) + self.log.debug("Arbiter booted") + self.log.info("Listening at: %s (%s)", listeners_str, self.pid) + self.log.info("Using worker: %s", self.cfg.worker_class_str) + systemd.sd_notify("READY=1\nSTATUS=Gunicorn arbiter booted", self.log) + + # check worker class requirements + if hasattr(self.worker_class, "check_config"): + self.worker_class.check_config(self.cfg, self.log) + + self.cfg.when_ready(self) + + def init_signals(self): + """\ + Initialize master signal handling. Most of the signals + are queued. Child signals only wake up the master. + """ + # close old PIPE + for p in self.PIPE: + os.close(p) + + # initialize the pipe + self.PIPE = pair = os.pipe() + for p in pair: + util.set_non_blocking(p) + util.close_on_exec(p) + + self.log.close_on_exec() + + # initialize all signals + for s in self.SIGNALS: + signal.signal(s, self.signal) + signal.signal(signal.SIGCHLD, self.handle_chld) + + def signal(self, sig, frame): + if len(self.SIG_QUEUE) < 5: + self.SIG_QUEUE.append(sig) + self.wakeup() + + def run(self): + "Main master loop." + self.start() + util._setproctitle("master [%s]" % self.proc_name) + + try: + self.manage_workers() + + while True: + self.maybe_promote_master() + + sig = self.SIG_QUEUE.pop(0) if self.SIG_QUEUE else None + if sig is None: + self.sleep() + self.murder_workers() + self.manage_workers() + continue + + if sig not in self.SIG_NAMES: + self.log.info("Ignoring unknown signal: %s", sig) + continue + + signame = self.SIG_NAMES.get(sig) + handler = getattr(self, "handle_%s" % signame, None) + if not handler: + self.log.error("Unhandled signal: %s", signame) + continue + self.log.info("Handling signal: %s", signame) + handler() + self.wakeup() + except (StopIteration, KeyboardInterrupt): + self.halt() + except HaltServer as inst: + self.halt(reason=inst.reason, exit_status=inst.exit_status) + except SystemExit: + raise + except Exception: + self.log.info("Unhandled exception in main loop", + exc_info=True) + self.stop(False) + if self.pidfile is not None: + self.pidfile.unlink() + sys.exit(-1) + + def handle_chld(self, sig, frame): + "SIGCHLD handling" + self.reap_workers() + self.wakeup() + + def handle_hup(self): + """\ + HUP handling. + - Reload configuration + - Start the new worker processes with a new configuration + - Gracefully shutdown the old worker processes + """ + self.log.info("Hang up: %s", self.master_name) + self.reload() + + def handle_term(self): + "SIGTERM handling" + raise StopIteration + + def handle_int(self): + "SIGINT handling" + self.stop(False) + raise StopIteration + + def handle_quit(self): + "SIGQUIT handling" + self.stop(False) + raise StopIteration + + def handle_ttin(self): + """\ + SIGTTIN handling. + Increases the number of workers by one. + """ + self.num_workers += 1 + self.manage_workers() + + def handle_ttou(self): + """\ + SIGTTOU handling. + Decreases the number of workers by one. + """ + if self.num_workers <= 1: + return + self.num_workers -= 1 + self.manage_workers() + + def handle_usr1(self): + """\ + SIGUSR1 handling. + Kill all workers by sending them a SIGUSR1 + """ + self.log.reopen_files() + self.kill_workers(signal.SIGUSR1) + + def handle_usr2(self): + """\ + SIGUSR2 handling. + Creates a new master/worker set as a slave of the current + master without affecting old workers. Use this to do live + deployment with the ability to backout a change. + """ + self.reexec() + + def handle_winch(self): + """SIGWINCH handling""" + if self.cfg.daemon: + self.log.info("graceful stop of workers") + self.num_workers = 0 + self.kill_workers(signal.SIGTERM) + else: + self.log.debug("SIGWINCH ignored. Not daemonized") + + def maybe_promote_master(self): + if self.master_pid == 0: + return + + if self.master_pid != os.getppid(): + self.log.info("Master has been promoted.") + # reset master infos + self.master_name = "Master" + self.master_pid = 0 + self.proc_name = self.cfg.proc_name + del os.environ['GUNICORN_PID'] + # rename the pidfile + if self.pidfile is not None: + self.pidfile.rename(self.cfg.pidfile) + # reset proctitle + util._setproctitle("master [%s]" % self.proc_name) + + def wakeup(self): + """\ + Wake up the arbiter by writing to the PIPE + """ + try: + os.write(self.PIPE[1], b'.') + except IOError as e: + if e.errno not in [errno.EAGAIN, errno.EINTR]: + raise + + def halt(self, reason=None, exit_status=0): + """ halt arbiter """ + self.stop() + self.log.info("Shutting down: %s", self.master_name) + if reason is not None: + self.log.info("Reason: %s", reason) + if self.pidfile is not None: + self.pidfile.unlink() + self.cfg.on_exit(self) + sys.exit(exit_status) + + def sleep(self): + """\ + Sleep until PIPE is readable or we timeout. + A readable PIPE means a signal occurred. + """ + try: + ready = select.select([self.PIPE[0]], [], [], 1.0) + if not ready[0]: + return + while os.read(self.PIPE[0], 1): + pass + except (select.error, OSError) as e: + # TODO: select.error is a subclass of OSError since Python 3.3. + error_number = getattr(e, 'errno', e.args[0]) + if error_number not in [errno.EAGAIN, errno.EINTR]: + raise + except KeyboardInterrupt: + sys.exit() + + def stop(self, graceful=True): + """\ + Stop workers + + :attr graceful: boolean, If True (the default) workers will be + killed gracefully (ie. trying to wait for the current connection) + """ + unlink = ( + self.reexec_pid == self.master_pid == 0 + and not self.systemd + and not self.cfg.reuse_port + ) + sock.close_sockets(self.LISTENERS, unlink) + + self.LISTENERS = [] + sig = signal.SIGTERM + if not graceful: + sig = signal.SIGQUIT + limit = time.time() + self.cfg.graceful_timeout + # instruct the workers to exit + self.kill_workers(sig) + # wait until the graceful timeout + while self.WORKERS and time.time() < limit: + time.sleep(0.1) + + self.kill_workers(signal.SIGKILL) + + def reexec(self): + """\ + Relaunch the master and workers. + """ + if self.reexec_pid != 0: + self.log.warning("USR2 signal ignored. Child exists.") + return + + if self.master_pid != 0: + self.log.warning("USR2 signal ignored. Parent exists.") + return + + master_pid = os.getpid() + self.reexec_pid = os.fork() + if self.reexec_pid != 0: + return + + self.cfg.pre_exec(self) + + environ = self.cfg.env_orig.copy() + environ['GUNICORN_PID'] = str(master_pid) + + if self.systemd: + environ['LISTEN_PID'] = str(os.getpid()) + environ['LISTEN_FDS'] = str(len(self.LISTENERS)) + else: + environ['GUNICORN_FD'] = ','.join( + str(l.fileno()) for l in self.LISTENERS) + + os.chdir(self.START_CTX['cwd']) + + # exec the process using the original environment + os.execvpe(self.START_CTX[0], self.START_CTX['args'], environ) + + def reload(self): + old_address = self.cfg.address + + # reset old environment + for k in self.cfg.env: + if k in self.cfg.env_orig: + # reset the key to the value it had before + # we launched gunicorn + os.environ[k] = self.cfg.env_orig[k] + else: + # delete the value set by gunicorn + try: + del os.environ[k] + except KeyError: + pass + + # reload conf + self.app.reload() + self.setup(self.app) + + # reopen log files + self.log.reopen_files() + + # do we need to change listener ? + if old_address != self.cfg.address: + # close all listeners + for l in self.LISTENERS: + l.close() + # init new listeners + self.LISTENERS = sock.create_sockets(self.cfg, self.log) + listeners_str = ",".join([str(l) for l in self.LISTENERS]) + self.log.info("Listening at: %s", listeners_str) + + # do some actions on reload + self.cfg.on_reload(self) + + # unlink pidfile + if self.pidfile is not None: + self.pidfile.unlink() + + # create new pidfile + if self.cfg.pidfile is not None: + self.pidfile = Pidfile(self.cfg.pidfile) + self.pidfile.create(self.pid) + + # set new proc_name + util._setproctitle("master [%s]" % self.proc_name) + + # spawn new workers + for _ in range(self.cfg.workers): + self.spawn_worker() + + # manage workers + self.manage_workers() + + def murder_workers(self): + """\ + Kill unused/idle workers + """ + if not self.timeout: + return + workers = list(self.WORKERS.items()) + for (pid, worker) in workers: + try: + if time.time() - worker.tmp.last_update() <= self.timeout: + continue + except (OSError, ValueError): + continue + + if not worker.aborted: + self.log.critical("WORKER TIMEOUT (pid:%s)", pid) + worker.aborted = True + self.kill_worker(pid, signal.SIGABRT) + else: + self.kill_worker(pid, signal.SIGKILL) + + def reap_workers(self): + """\ + Reap workers to avoid zombie processes + """ + try: + while True: + wpid, status = os.waitpid(-1, os.WNOHANG) + if not wpid: + break + if self.reexec_pid == wpid: + self.reexec_pid = 0 + else: + # A worker was terminated. If the termination reason was + # that it could not boot, we'll shut it down to avoid + # infinite start/stop cycles. + exitcode = status >> 8 + if exitcode == self.WORKER_BOOT_ERROR: + reason = "Worker failed to boot." + raise HaltServer(reason, self.WORKER_BOOT_ERROR) + if exitcode == self.APP_LOAD_ERROR: + reason = "App failed to load." + raise HaltServer(reason, self.APP_LOAD_ERROR) + + worker = self.WORKERS.pop(wpid, None) + if not worker: + continue + worker.tmp.close() + self.cfg.child_exit(self, worker) + except OSError as e: + if e.errno != errno.ECHILD: + raise + + def manage_workers(self): + """\ + Maintain the number of workers by spawning or killing + as required. + """ + if len(self.WORKERS) < self.num_workers: + self.spawn_workers() + + workers = self.WORKERS.items() + workers = sorted(workers, key=lambda w: w[1].age) + while len(workers) > self.num_workers: + (pid, _) = workers.pop(0) + self.kill_worker(pid, signal.SIGTERM) + + active_worker_count = len(workers) + if self._last_logged_active_worker_count != active_worker_count: + self._last_logged_active_worker_count = active_worker_count + self.log.debug("{0} workers".format(active_worker_count), + extra={"metric": "gunicorn.workers", + "value": active_worker_count, + "mtype": "gauge"}) + + def spawn_worker(self): + self.worker_age += 1 + worker = self.worker_class(self.worker_age, self.pid, self.LISTENERS, + self.app, self.timeout / 2.0, + self.cfg, self.log) + self.cfg.pre_fork(self, worker) + pid = os.fork() + if pid != 0: + worker.pid = pid + self.WORKERS[pid] = worker + return pid + + # Do not inherit the temporary files of other workers + for sibling in self.WORKERS.values(): + sibling.tmp.close() + + # Process Child + worker.pid = os.getpid() + try: + util._setproctitle("worker [%s]" % self.proc_name) + self.log.info("Booting worker with pid: %s", worker.pid) + self.cfg.post_fork(self, worker) + worker.init_process() + sys.exit(0) + except SystemExit: + raise + except AppImportError as e: + self.log.debug("Exception while loading the application", + exc_info=True) + print("%s" % e, file=sys.stderr) + sys.stderr.flush() + sys.exit(self.APP_LOAD_ERROR) + except: + self.log.exception("Exception in worker process") + if not worker.booted: + sys.exit(self.WORKER_BOOT_ERROR) + sys.exit(-1) + finally: + self.log.info("Worker exiting (pid: %s)", worker.pid) + try: + worker.tmp.close() + self.cfg.worker_exit(self, worker) + except: + self.log.warning("Exception during worker exit:\n%s", + traceback.format_exc()) + + def spawn_workers(self): + """\ + Spawn new workers as needed. + + This is where a worker process leaves the main loop + of the master process. + """ + + for _ in range(self.num_workers - len(self.WORKERS)): + self.spawn_worker() + time.sleep(0.1 * random.random()) + + def kill_workers(self, sig): + """\ + Kill all workers with the signal `sig` + :attr sig: `signal.SIG*` value + """ + worker_pids = list(self.WORKERS.keys()) + for pid in worker_pids: + self.kill_worker(pid, sig) + + def kill_worker(self, pid, sig): + """\ + Kill a worker + + :attr pid: int, worker pid + :attr sig: `signal.SIG*` value + """ + try: + os.kill(pid, sig) + except OSError as e: + if e.errno == errno.ESRCH: + try: + worker = self.WORKERS.pop(pid) + worker.tmp.close() + self.cfg.worker_exit(self, worker) + return + except (KeyError, OSError): + return + raise diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/config.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/config.py new file mode 100644 index 0000000..e8e0f92 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/config.py @@ -0,0 +1,2012 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +# Please remember to run "make -C docs html" after update "desc" attributes. + +import argparse +import copy +import grp +import inspect +import os +import pwd +import re +import shlex +import ssl +import sys +import textwrap + +from gunicorn import __version__, util +from gunicorn.errors import ConfigError +from gunicorn.reloader import reloader_engines + +KNOWN_SETTINGS = [] +PLATFORM = sys.platform + + +def make_settings(ignore=None): + settings = {} + ignore = ignore or () + for s in KNOWN_SETTINGS: + setting = s() + if setting.name in ignore: + continue + settings[setting.name] = setting.copy() + return settings + + +def auto_int(_, x): + # for compatible with octal numbers in python3 + if re.match(r'0(\d)', x, re.IGNORECASE): + x = x.replace('0', '0o', 1) + return int(x, 0) + + +class Config(object): + + def __init__(self, usage=None, prog=None): + self.settings = make_settings() + self.usage = usage + self.prog = prog or os.path.basename(sys.argv[0]) + self.env_orig = os.environ.copy() + + def __getattr__(self, name): + if name not in self.settings: + raise AttributeError("No configuration setting for: %s" % name) + return self.settings[name].get() + + def __setattr__(self, name, value): + if name != "settings" and name in self.settings: + raise AttributeError("Invalid access!") + super().__setattr__(name, value) + + def set(self, name, value): + if name not in self.settings: + raise AttributeError("No configuration setting for: %s" % name) + self.settings[name].set(value) + + def get_cmd_args_from_env(self): + if 'GUNICORN_CMD_ARGS' in self.env_orig: + return shlex.split(self.env_orig['GUNICORN_CMD_ARGS']) + return [] + + def parser(self): + kwargs = { + "usage": self.usage, + "prog": self.prog + } + parser = argparse.ArgumentParser(**kwargs) + parser.add_argument("-v", "--version", + action="version", default=argparse.SUPPRESS, + version="%(prog)s (version " + __version__ + ")\n", + help="show program's version number and exit") + parser.add_argument("args", nargs="*", help=argparse.SUPPRESS) + + keys = sorted(self.settings, key=self.settings.__getitem__) + for k in keys: + self.settings[k].add_option(parser) + + return parser + + @property + def worker_class_str(self): + uri = self.settings['worker_class'].get() + + ## are we using a threaded worker? + is_sync = uri.endswith('SyncWorker') or uri == 'sync' + if is_sync and self.threads > 1: + return "threads" + return uri + + @property + def worker_class(self): + uri = self.settings['worker_class'].get() + + ## are we using a threaded worker? + is_sync = uri.endswith('SyncWorker') or uri == 'sync' + if is_sync and self.threads > 1: + uri = "gunicorn.workers.gthread.ThreadWorker" + + worker_class = util.load_class(uri) + if hasattr(worker_class, "setup"): + worker_class.setup() + return worker_class + + @property + def address(self): + s = self.settings['bind'].get() + return [util.parse_address(util.bytes_to_str(bind)) for bind in s] + + @property + def uid(self): + return self.settings['user'].get() + + @property + def gid(self): + return self.settings['group'].get() + + @property + def proc_name(self): + pn = self.settings['proc_name'].get() + if pn is not None: + return pn + else: + return self.settings['default_proc_name'].get() + + @property + def logger_class(self): + uri = self.settings['logger_class'].get() + if uri == "simple": + # support the default + uri = LoggerClass.default + + # if default logger is in use, and statsd is on, automagically switch + # to the statsd logger + if uri == LoggerClass.default: + if 'statsd_host' in self.settings and self.settings['statsd_host'].value is not None: + uri = "gunicorn.instrument.statsd.Statsd" + + logger_class = util.load_class( + uri, + default="gunicorn.glogging.Logger", + section="gunicorn.loggers") + + if hasattr(logger_class, "install"): + logger_class.install() + return logger_class + + @property + def is_ssl(self): + return self.certfile or self.keyfile + + @property + def ssl_options(self): + opts = {} + for name, value in self.settings.items(): + if value.section == 'SSL': + opts[name] = value.get() + return opts + + @property + def env(self): + raw_env = self.settings['raw_env'].get() + env = {} + + if not raw_env: + return env + + for e in raw_env: + s = util.bytes_to_str(e) + try: + k, v = s.split('=', 1) + except ValueError: + raise RuntimeError("environment setting %r invalid" % s) + + env[k] = v + + return env + + @property + def sendfile(self): + if self.settings['sendfile'].get() is not None: + return False + + if 'SENDFILE' in os.environ: + sendfile = os.environ['SENDFILE'].lower() + return sendfile in ['y', '1', 'yes', 'true'] + + return True + + @property + def reuse_port(self): + return self.settings['reuse_port'].get() + + @property + def paste_global_conf(self): + raw_global_conf = self.settings['raw_paste_global_conf'].get() + if raw_global_conf is None: + return None + + global_conf = {} + for e in raw_global_conf: + s = util.bytes_to_str(e) + try: + k, v = re.split(r'(?= 0.24.1 (or install it via + ``pip install gunicorn[eventlet]``) + * ``gevent`` - Requires gevent >= 1.4 (or install it via + ``pip install gunicorn[gevent]``) + * ``tornado`` - Requires tornado >= 0.2 (or install it via + ``pip install gunicorn[tornado]``) + * ``gthread`` - Python 2 requires the futures package to be installed + (or install it via ``pip install gunicorn[gthread]``) + + Optionally, you can provide your own worker by giving Gunicorn a + Python path to a subclass of ``gunicorn.workers.base.Worker``. + This alternative syntax will load the gevent class: + ``gunicorn.workers.ggevent.GeventWorker``. + """ + +class WorkerThreads(Setting): + name = "threads" + section = "Worker Processes" + cli = ["--threads"] + meta = "INT" + validator = validate_pos_int + type = int + default = 1 + desc = """\ + The number of worker threads for handling requests. + + Run each worker with the specified number of threads. + + A positive integer generally in the ``2-4 x $(NUM_CORES)`` range. + You'll want to vary this a bit to find the best for your particular + application's work load. + + If it is not defined, the default is ``1``. + + This setting only affects the Gthread worker type. + + .. note:: + If you try to use the ``sync`` worker type and set the ``threads`` + setting to more than 1, the ``gthread`` worker type will be used + instead. + """ + + +class WorkerConnections(Setting): + name = "worker_connections" + section = "Worker Processes" + cli = ["--worker-connections"] + meta = "INT" + validator = validate_pos_int + type = int + default = 1000 + desc = """\ + The maximum number of simultaneous clients. + + This setting only affects the Eventlet and Gevent worker types. + """ + + +class MaxRequests(Setting): + name = "max_requests" + section = "Worker Processes" + cli = ["--max-requests"] + meta = "INT" + validator = validate_pos_int + type = int + default = 0 + desc = """\ + The maximum number of requests a worker will process before restarting. + + Any value greater than zero will limit the number of requests a worker + will process before automatically restarting. This is a simple method + to help limit the damage of memory leaks. + + If this is set to zero (the default) then the automatic worker + restarts are disabled. + """ + + +class MaxRequestsJitter(Setting): + name = "max_requests_jitter" + section = "Worker Processes" + cli = ["--max-requests-jitter"] + meta = "INT" + validator = validate_pos_int + type = int + default = 0 + desc = """\ + The maximum jitter to add to the *max_requests* setting. + + The jitter causes the restart per worker to be randomized by + ``randint(0, max_requests_jitter)``. This is intended to stagger worker + restarts to avoid all workers restarting at the same time. + + .. versionadded:: 19.2 + """ + + +class Timeout(Setting): + name = "timeout" + section = "Worker Processes" + cli = ["-t", "--timeout"] + meta = "INT" + validator = validate_pos_int + type = int + default = 30 + desc = """\ + Workers silent for more than this many seconds are killed and restarted. + + Generally set to thirty seconds. Only set this noticeably higher if + you're sure of the repercussions for sync workers. For the non sync + workers it just means that the worker process is still communicating and + is not tied to the length of time required to handle a single request. + """ + + +class GracefulTimeout(Setting): + name = "graceful_timeout" + section = "Worker Processes" + cli = ["--graceful-timeout"] + meta = "INT" + validator = validate_pos_int + type = int + default = 30 + desc = """\ + Timeout for graceful workers restart. + + After receiving a restart signal, workers have this much time to finish + serving requests. Workers still alive after the timeout (starting from + the receipt of the restart signal) are force killed. + """ + + +class Keepalive(Setting): + name = "keepalive" + section = "Worker Processes" + cli = ["--keep-alive"] + meta = "INT" + validator = validate_pos_int + type = int + default = 2 + desc = """\ + The number of seconds to wait for requests on a Keep-Alive connection. + + Generally set in the 1-5 seconds range for servers with direct connection + to the client (e.g. when you don't have separate load balancer). When + Gunicorn is deployed behind a load balancer, it often makes sense to + set this to a higher value. + + .. note:: + ``sync`` worker does not support persistent connections and will + ignore this option. + """ + + +class LimitRequestLine(Setting): + name = "limit_request_line" + section = "Security" + cli = ["--limit-request-line"] + meta = "INT" + validator = validate_pos_int + type = int + default = 4094 + desc = """\ + The maximum size of HTTP request line in bytes. + + This parameter is used to limit the allowed size of a client's + HTTP request-line. Since the request-line consists of the HTTP + method, URI, and protocol version, this directive places a + restriction on the length of a request-URI allowed for a request + on the server. A server needs this value to be large enough to + hold any of its resource names, including any information that + might be passed in the query part of a GET request. Value is a number + from 0 (unlimited) to 8190. + + This parameter can be used to prevent any DDOS attack. + """ + + +class LimitRequestFields(Setting): + name = "limit_request_fields" + section = "Security" + cli = ["--limit-request-fields"] + meta = "INT" + validator = validate_pos_int + type = int + default = 100 + desc = """\ + Limit the number of HTTP headers fields in a request. + + This parameter is used to limit the number of headers in a request to + prevent DDOS attack. Used with the *limit_request_field_size* it allows + more safety. By default this value is 100 and can't be larger than + 32768. + """ + + +class LimitRequestFieldSize(Setting): + name = "limit_request_field_size" + section = "Security" + cli = ["--limit-request-field_size"] + meta = "INT" + validator = validate_pos_int + type = int + default = 8190 + desc = """\ + Limit the allowed size of an HTTP request header field. + + Value is a positive number or 0. Setting it to 0 will allow unlimited + header field sizes. + + .. warning:: + Setting this parameter to a very high or unlimited value can open + up for DDOS attacks. + """ + + +class Reload(Setting): + name = "reload" + section = 'Debugging' + cli = ['--reload'] + validator = validate_bool + action = 'store_true' + default = False + + desc = '''\ + Restart workers when code changes. + + This setting is intended for development. It will cause workers to be + restarted whenever application code changes. + + The reloader is incompatible with application preloading. When using a + paste configuration be sure that the server block does not import any + application code or the reload will not work as designed. + + The default behavior is to attempt inotify with a fallback to file + system polling. Generally, inotify should be preferred if available + because it consumes less system resources. + + .. note:: + In order to use the inotify reloader, you must have the ``inotify`` + package installed. + ''' + + +class ReloadEngine(Setting): + name = "reload_engine" + section = "Debugging" + cli = ["--reload-engine"] + meta = "STRING" + validator = validate_reload_engine + default = "auto" + desc = """\ + The implementation that should be used to power :ref:`reload`. + + Valid engines are: + + * 'auto' + * 'poll' + * 'inotify' (requires inotify) + + .. versionadded:: 19.7 + """ + + +class ReloadExtraFiles(Setting): + name = "reload_extra_files" + action = "append" + section = "Debugging" + cli = ["--reload-extra-file"] + meta = "FILES" + validator = validate_list_of_existing_files + default = [] + desc = """\ + Extends :ref:`reload` option to also watch and reload on additional files + (e.g., templates, configurations, specifications, etc.). + + .. versionadded:: 19.8 + """ + + +class Spew(Setting): + name = "spew" + section = "Debugging" + cli = ["--spew"] + validator = validate_bool + action = "store_true" + default = False + desc = """\ + Install a trace function that spews every line executed by the server. + + This is the nuclear option. + """ + + +class ConfigCheck(Setting): + name = "check_config" + section = "Debugging" + cli = ["--check-config"] + validator = validate_bool + action = "store_true" + default = False + desc = """\ + Check the configuration. + """ + + +class PreloadApp(Setting): + name = "preload_app" + section = "Server Mechanics" + cli = ["--preload"] + validator = validate_bool + action = "store_true" + default = False + desc = """\ + Load application code before the worker processes are forked. + + By preloading an application you can save some RAM resources as well as + speed up server boot times. Although, if you defer application loading + to each worker process, you can reload your application code easily by + restarting workers. + """ + + +class Sendfile(Setting): + name = "sendfile" + section = "Server Mechanics" + cli = ["--no-sendfile"] + validator = validate_bool + action = "store_const" + const = False + + desc = """\ + Disables the use of ``sendfile()``. + + If not set, the value of the ``SENDFILE`` environment variable is used + to enable or disable its usage. + + .. versionadded:: 19.2 + .. versionchanged:: 19.4 + Swapped ``--sendfile`` with ``--no-sendfile`` to actually allow + disabling. + .. versionchanged:: 19.6 + added support for the ``SENDFILE`` environment variable + """ + + +class ReusePort(Setting): + name = "reuse_port" + section = "Server Mechanics" + cli = ["--reuse-port"] + validator = validate_bool + action = "store_true" + default = False + + desc = """\ + Set the ``SO_REUSEPORT`` flag on the listening socket. + + .. versionadded:: 19.8 + """ + + +class Chdir(Setting): + name = "chdir" + section = "Server Mechanics" + cli = ["--chdir"] + validator = validate_chdir + default = util.getcwd() + desc = """\ + Chdir to specified directory before apps loading. + """ + + +class Daemon(Setting): + name = "daemon" + section = "Server Mechanics" + cli = ["-D", "--daemon"] + validator = validate_bool + action = "store_true" + default = False + desc = """\ + Daemonize the Gunicorn process. + + Detaches the server from the controlling terminal and enters the + background. + """ + +class Env(Setting): + name = "raw_env" + action = "append" + section = "Server Mechanics" + cli = ["-e", "--env"] + meta = "ENV" + validator = validate_list_string + default = [] + + desc = """\ + Set environment variable (key=value). + + Pass variables to the execution environment. Ex.:: + + $ gunicorn -b 127.0.0.1:8000 --env FOO=1 test:app + + and test for the foo variable environment in your application. + """ + + +class Pidfile(Setting): + name = "pidfile" + section = "Server Mechanics" + cli = ["-p", "--pid"] + meta = "FILE" + validator = validate_string + default = None + desc = """\ + A filename to use for the PID file. + + If not set, no PID file will be written. + """ + +class WorkerTmpDir(Setting): + name = "worker_tmp_dir" + section = "Server Mechanics" + cli = ["--worker-tmp-dir"] + meta = "DIR" + validator = validate_string + default = None + desc = """\ + A directory to use for the worker heartbeat temporary file. + + If not set, the default temporary directory will be used. + + .. note:: + The current heartbeat system involves calling ``os.fchmod`` on + temporary file handlers and may block a worker for arbitrary time + if the directory is on a disk-backed filesystem. + + See :ref:`blocking-os-fchmod` for more detailed information + and a solution for avoiding this problem. + """ + + +class User(Setting): + name = "user" + section = "Server Mechanics" + cli = ["-u", "--user"] + meta = "USER" + validator = validate_user + default = os.geteuid() + desc = """\ + Switch worker processes to run as this user. + + A valid user id (as an integer) or the name of a user that can be + retrieved with a call to ``pwd.getpwnam(value)`` or ``None`` to not + change the worker process user. + """ + + +class Group(Setting): + name = "group" + section = "Server Mechanics" + cli = ["-g", "--group"] + meta = "GROUP" + validator = validate_group + default = os.getegid() + desc = """\ + Switch worker process to run as this group. + + A valid group id (as an integer) or the name of a user that can be + retrieved with a call to ``pwd.getgrnam(value)`` or ``None`` to not + change the worker processes group. + """ + +class Umask(Setting): + name = "umask" + section = "Server Mechanics" + cli = ["-m", "--umask"] + meta = "INT" + validator = validate_pos_int + type = auto_int + default = 0 + desc = """\ + A bit mask for the file mode on files written by Gunicorn. + + Note that this affects unix socket permissions. + + A valid value for the ``os.umask(mode)`` call or a string compatible + with ``int(value, 0)`` (``0`` means Python guesses the base, so values + like ``0``, ``0xFF``, ``0022`` are valid for decimal, hex, and octal + representations) + """ + + +class Initgroups(Setting): + name = "initgroups" + section = "Server Mechanics" + cli = ["--initgroups"] + validator = validate_bool + action = 'store_true' + default = False + + desc = """\ + If true, set the worker process's group access list with all of the + groups of which the specified username is a member, plus the specified + group id. + + .. versionadded:: 19.7 + """ + + +class TmpUploadDir(Setting): + name = "tmp_upload_dir" + section = "Server Mechanics" + meta = "DIR" + validator = validate_string + default = None + desc = """\ + Directory to store temporary request data as they are read. + + This may disappear in the near future. + + This path should be writable by the process permissions set for Gunicorn + workers. If not specified, Gunicorn will choose a system generated + temporary directory. + """ + + +class SecureSchemeHeader(Setting): + name = "secure_scheme_headers" + section = "Server Mechanics" + validator = validate_dict + default = { + "X-FORWARDED-PROTOCOL": "ssl", + "X-FORWARDED-PROTO": "https", + "X-FORWARDED-SSL": "on" + } + desc = """\ + + A dictionary containing headers and values that the front-end proxy + uses to indicate HTTPS requests. These tell Gunicorn to set + ``wsgi.url_scheme`` to ``https``, so your application can tell that the + request is secure. + + The dictionary should map upper-case header names to exact string + values. The value comparisons are case-sensitive, unlike the header + names, so make sure they're exactly what your front-end proxy sends + when handling HTTPS requests. + + It is important that your front-end proxy configuration ensures that + the headers defined here can not be passed directly from the client. + """ + + +class ForwardedAllowIPS(Setting): + name = "forwarded_allow_ips" + section = "Server Mechanics" + cli = ["--forwarded-allow-ips"] + meta = "STRING" + validator = validate_string_to_list + default = os.environ.get("FORWARDED_ALLOW_IPS", "127.0.0.1") + desc = """\ + Front-end's IPs from which allowed to handle set secure headers. + (comma separate). + + Set to ``*`` to disable checking of Front-end IPs (useful for setups + where you don't know in advance the IP address of Front-end, but + you still trust the environment). + + By default, the value of the ``FORWARDED_ALLOW_IPS`` environment + variable. If it is not defined, the default is ``"127.0.0.1"``. + """ + + +class AccessLog(Setting): + name = "accesslog" + section = "Logging" + cli = ["--access-logfile"] + meta = "FILE" + validator = validate_string + default = None + desc = """\ + The Access log file to write to. + + ``'-'`` means log to stdout. + """ + +class DisableRedirectAccessToSyslog(Setting): + name = "disable_redirect_access_to_syslog" + section = "Logging" + cli = ["--disable-redirect-access-to-syslog"] + validator = validate_bool + action = 'store_true' + default = False + desc = """\ + Disable redirect access logs to syslog. + + .. versionadded:: 19.8 + """ + + +class AccessLogFormat(Setting): + name = "access_log_format" + section = "Logging" + cli = ["--access-logformat"] + meta = "STRING" + validator = validate_string + default = '%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"' + desc = """\ + The access log format. + + =========== =========== + Identifier Description + =========== =========== + h remote address + l ``'-'`` + u user name + t date of the request + r status line (e.g. ``GET / HTTP/1.1``) + m request method + U URL path without query string + q query string + H protocol + s status + B response length + b response length or ``'-'`` (CLF format) + f referer + a user agent + T request time in seconds + D request time in microseconds + L request time in decimal seconds + p process ID + {header}i request header + {header}o response header + {variable}e environment variable + =========== =========== + + Use lowercase for header and environment variable names, and put + ``{...}x`` names inside ``%(...)s``. For example:: + + %({x-forwarded-for}i)s + """ + + +class ErrorLog(Setting): + name = "errorlog" + section = "Logging" + cli = ["--error-logfile", "--log-file"] + meta = "FILE" + validator = validate_string + default = '-' + desc = """\ + The Error log file to write to. + + Using ``'-'`` for FILE makes gunicorn log to stderr. + + .. versionchanged:: 19.2 + Log to stderr by default. + + """ + + +class Loglevel(Setting): + name = "loglevel" + section = "Logging" + cli = ["--log-level"] + meta = "LEVEL" + validator = validate_string + default = "info" + desc = """\ + The granularity of Error log outputs. + + Valid level names are: + + * debug + * info + * warning + * error + * critical + """ + + +class CaptureOutput(Setting): + name = "capture_output" + section = "Logging" + cli = ["--capture-output"] + validator = validate_bool + action = 'store_true' + default = False + desc = """\ + Redirect stdout/stderr to specified file in :ref:`errorlog`. + + .. versionadded:: 19.6 + """ + + +class LoggerClass(Setting): + name = "logger_class" + section = "Logging" + cli = ["--logger-class"] + meta = "STRING" + validator = validate_class + default = "gunicorn.glogging.Logger" + desc = """\ + The logger you want to use to log events in Gunicorn. + + The default class (``gunicorn.glogging.Logger``) handle most of + normal usages in logging. It provides error and access logging. + + You can provide your own logger by giving Gunicorn a + Python path to a subclass like ``gunicorn.glogging.Logger``. + """ + + +class LogConfig(Setting): + name = "logconfig" + section = "Logging" + cli = ["--log-config"] + meta = "FILE" + validator = validate_string + default = None + desc = """\ + The log config file to use. + Gunicorn uses the standard Python logging module's Configuration + file format. + """ + + +class LogConfigDict(Setting): + name = "logconfig_dict" + section = "Logging" + cli = ["--log-config-dict"] + validator = validate_dict + default = {} + desc = """\ + The log config dictionary to use, using the standard Python + logging module's dictionary configuration format. This option + takes precedence over the :ref:`logconfig` option, which uses the + older file configuration format. + + Format: https://docs.python.org/3/library/logging.config.html#logging.config.dictConfig + + .. versionadded:: 19.8 + """ + + +class SyslogTo(Setting): + name = "syslog_addr" + section = "Logging" + cli = ["--log-syslog-to"] + meta = "SYSLOG_ADDR" + validator = validate_string + + if PLATFORM == "darwin": + default = "unix:///var/run/syslog" + elif PLATFORM in ('freebsd', 'dragonfly', ): + default = "unix:///var/run/log" + elif PLATFORM == "openbsd": + default = "unix:///dev/log" + else: + default = "udp://localhost:514" + + desc = """\ + Address to send syslog messages. + + Address is a string of the form: + + * ``unix://PATH#TYPE`` : for unix domain socket. ``TYPE`` can be ``stream`` + for the stream driver or ``dgram`` for the dgram driver. + ``stream`` is the default. + * ``udp://HOST:PORT`` : for UDP sockets + * ``tcp://HOST:PORT`` : for TCP sockets + + """ + + +class Syslog(Setting): + name = "syslog" + section = "Logging" + cli = ["--log-syslog"] + validator = validate_bool + action = 'store_true' + default = False + desc = """\ + Send *Gunicorn* logs to syslog. + + .. versionchanged:: 19.8 + You can now disable sending access logs by using the + :ref:`disable-redirect-access-to-syslog` setting. + """ + + +class SyslogPrefix(Setting): + name = "syslog_prefix" + section = "Logging" + cli = ["--log-syslog-prefix"] + meta = "SYSLOG_PREFIX" + validator = validate_string + default = None + desc = """\ + Makes Gunicorn use the parameter as program-name in the syslog entries. + + All entries will be prefixed by ``gunicorn.``. By default the + program name is the name of the process. + """ + + +class SyslogFacility(Setting): + name = "syslog_facility" + section = "Logging" + cli = ["--log-syslog-facility"] + meta = "SYSLOG_FACILITY" + validator = validate_string + default = "user" + desc = """\ + Syslog facility name + """ + + +class EnableStdioInheritance(Setting): + name = "enable_stdio_inheritance" + section = "Logging" + cli = ["-R", "--enable-stdio-inheritance"] + validator = validate_bool + default = False + action = "store_true" + desc = """\ + Enable stdio inheritance. + + Enable inheritance for stdio file descriptors in daemon mode. + + Note: To disable the Python stdout buffering, you can to set the user + environment variable ``PYTHONUNBUFFERED`` . + """ + + +# statsD monitoring +class StatsdHost(Setting): + name = "statsd_host" + section = "Logging" + cli = ["--statsd-host"] + meta = "STATSD_ADDR" + default = None + validator = validate_hostport + desc = """\ + ``host:port`` of the statsd server to log to. + + .. versionadded:: 19.1 + """ + +# Datadog Statsd (dogstatsd) tags. https://docs.datadoghq.com/developers/dogstatsd/ +class DogstatsdTags(Setting): + name = "dogstatsd_tags" + section = "Logging" + cli = ["--dogstatsd-tags"] + meta = "DOGSTATSD_TAGS" + default = "" + validator = validate_string + desc = """\ + A comma-delimited list of datadog statsd (dogstatsd) tags to append to statsd metrics. + + .. versionadded:: 20 + """ + +class StatsdPrefix(Setting): + name = "statsd_prefix" + section = "Logging" + cli = ["--statsd-prefix"] + meta = "STATSD_PREFIX" + default = "" + validator = validate_string + desc = """\ + Prefix to use when emitting statsd metrics (a trailing ``.`` is added, + if not provided). + + .. versionadded:: 19.2 + """ + + +class Procname(Setting): + name = "proc_name" + section = "Process Naming" + cli = ["-n", "--name"] + meta = "STRING" + validator = validate_string + default = None + desc = """\ + A base to use with setproctitle for process naming. + + This affects things like ``ps`` and ``top``. If you're going to be + running more than one instance of Gunicorn you'll probably want to set a + name to tell them apart. This requires that you install the setproctitle + module. + + If not set, the *default_proc_name* setting will be used. + """ + + +class DefaultProcName(Setting): + name = "default_proc_name" + section = "Process Naming" + validator = validate_string + default = "gunicorn" + desc = """\ + Internal setting that is adjusted for each type of application. + """ + + +class PythonPath(Setting): + name = "pythonpath" + section = "Server Mechanics" + cli = ["--pythonpath"] + meta = "STRING" + validator = validate_string + default = None + desc = """\ + A comma-separated list of directories to add to the Python path. + + e.g. + ``'/home/djangoprojects/myproject,/home/python/mylibrary'``. + """ + + +class Paste(Setting): + name = "paste" + section = "Server Mechanics" + cli = ["--paste", "--paster"] + meta = "STRING" + validator = validate_string + default = None + desc = """\ + Load a PasteDeploy config file. The argument may contain a ``#`` + symbol followed by the name of an app section from the config file, + e.g. ``production.ini#admin``. + + At this time, using alternate server blocks is not supported. Use the + command line arguments to control server configuration instead. + """ + + +class OnStarting(Setting): + name = "on_starting" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def on_starting(server): + pass + default = staticmethod(on_starting) + desc = """\ + Called just before the master process is initialized. + + The callable needs to accept a single instance variable for the Arbiter. + """ + + +class OnReload(Setting): + name = "on_reload" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def on_reload(server): + pass + default = staticmethod(on_reload) + desc = """\ + Called to recycle workers during a reload via SIGHUP. + + The callable needs to accept a single instance variable for the Arbiter. + """ + + +class WhenReady(Setting): + name = "when_ready" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def when_ready(server): + pass + default = staticmethod(when_ready) + desc = """\ + Called just after the server is started. + + The callable needs to accept a single instance variable for the Arbiter. + """ + + +class Prefork(Setting): + name = "pre_fork" + section = "Server Hooks" + validator = validate_callable(2) + type = callable + + def pre_fork(server, worker): + pass + default = staticmethod(pre_fork) + desc = """\ + Called just before a worker is forked. + + The callable needs to accept two instance variables for the Arbiter and + new Worker. + """ + + +class Postfork(Setting): + name = "post_fork" + section = "Server Hooks" + validator = validate_callable(2) + type = callable + + def post_fork(server, worker): + pass + default = staticmethod(post_fork) + desc = """\ + Called just after a worker has been forked. + + The callable needs to accept two instance variables for the Arbiter and + new Worker. + """ + + +class PostWorkerInit(Setting): + name = "post_worker_init" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def post_worker_init(worker): + pass + + default = staticmethod(post_worker_init) + desc = """\ + Called just after a worker has initialized the application. + + The callable needs to accept one instance variable for the initialized + Worker. + """ + +class WorkerInt(Setting): + name = "worker_int" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def worker_int(worker): + pass + + default = staticmethod(worker_int) + desc = """\ + Called just after a worker exited on SIGINT or SIGQUIT. + + The callable needs to accept one instance variable for the initialized + Worker. + """ + + +class WorkerAbort(Setting): + name = "worker_abort" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def worker_abort(worker): + pass + + default = staticmethod(worker_abort) + desc = """\ + Called when a worker received the SIGABRT signal. + + This call generally happens on timeout. + + The callable needs to accept one instance variable for the initialized + Worker. + """ + + +class PreExec(Setting): + name = "pre_exec" + section = "Server Hooks" + validator = validate_callable(1) + type = callable + + def pre_exec(server): + pass + default = staticmethod(pre_exec) + desc = """\ + Called just before a new master process is forked. + + The callable needs to accept a single instance variable for the Arbiter. + """ + + +class PreRequest(Setting): + name = "pre_request" + section = "Server Hooks" + validator = validate_callable(2) + type = callable + + def pre_request(worker, req): + worker.log.debug("%s %s" % (req.method, req.path)) + default = staticmethod(pre_request) + desc = """\ + Called just before a worker processes the request. + + The callable needs to accept two instance variables for the Worker and + the Request. + """ + + +class PostRequest(Setting): + name = "post_request" + section = "Server Hooks" + validator = validate_post_request + type = callable + + def post_request(worker, req, environ, resp): + pass + default = staticmethod(post_request) + desc = """\ + Called after a worker processes the request. + + The callable needs to accept two instance variables for the Worker and + the Request. + """ + + +class ChildExit(Setting): + name = "child_exit" + section = "Server Hooks" + validator = validate_callable(2) + type = callable + + def child_exit(server, worker): + pass + default = staticmethod(child_exit) + desc = """\ + Called just after a worker has been exited, in the master process. + + The callable needs to accept two instance variables for the Arbiter and + the just-exited Worker. + + .. versionadded:: 19.7 + """ + + +class WorkerExit(Setting): + name = "worker_exit" + section = "Server Hooks" + validator = validate_callable(2) + type = callable + + def worker_exit(server, worker): + pass + default = staticmethod(worker_exit) + desc = """\ + Called just after a worker has been exited, in the worker process. + + The callable needs to accept two instance variables for the Arbiter and + the just-exited Worker. + """ + + +class NumWorkersChanged(Setting): + name = "nworkers_changed" + section = "Server Hooks" + validator = validate_callable(3) + type = callable + + def nworkers_changed(server, new_value, old_value): + pass + default = staticmethod(nworkers_changed) + desc = """\ + Called just after *num_workers* has been changed. + + The callable needs to accept an instance variable of the Arbiter and + two integers of number of workers after and before change. + + If the number of workers is set for the first time, *old_value* would + be ``None``. + """ + +class OnExit(Setting): + name = "on_exit" + section = "Server Hooks" + validator = validate_callable(1) + + def on_exit(server): + pass + + default = staticmethod(on_exit) + desc = """\ + Called just before exiting Gunicorn. + + The callable needs to accept a single instance variable for the Arbiter. + """ + + +class ProxyProtocol(Setting): + name = "proxy_protocol" + section = "Server Mechanics" + cli = ["--proxy-protocol"] + validator = validate_bool + default = False + action = "store_true" + desc = """\ + Enable detect PROXY protocol (PROXY mode). + + Allow using HTTP and Proxy together. It may be useful for work with + stunnel as HTTPS frontend and Gunicorn as HTTP server. + + PROXY protocol: http://haproxy.1wt.eu/download/1.5/doc/proxy-protocol.txt + + Example for stunnel config:: + + [https] + protocol = proxy + accept = 443 + connect = 80 + cert = /etc/ssl/certs/stunnel.pem + key = /etc/ssl/certs/stunnel.key + """ + + +class ProxyAllowFrom(Setting): + name = "proxy_allow_ips" + section = "Server Mechanics" + cli = ["--proxy-allow-from"] + validator = validate_string_to_list + default = "127.0.0.1" + desc = """\ + Front-end's IPs from which allowed accept proxy requests (comma separate). + + Set to ``*`` to disable checking of Front-end IPs (useful for setups + where you don't know in advance the IP address of Front-end, but + you still trust the environment) + """ + + +class KeyFile(Setting): + name = "keyfile" + section = "SSL" + cli = ["--keyfile"] + meta = "FILE" + validator = validate_string + default = None + desc = """\ + SSL key file + """ + + +class CertFile(Setting): + name = "certfile" + section = "SSL" + cli = ["--certfile"] + meta = "FILE" + validator = validate_string + default = None + desc = """\ + SSL certificate file + """ + +class SSLVersion(Setting): + name = "ssl_version" + section = "SSL" + cli = ["--ssl-version"] + validator = validate_ssl_version + default = ssl.PROTOCOL_SSLv23 + desc = """\ + SSL version to use. + + ============= ============ + --ssl-version Description + ============= ============ + SSLv3 SSLv3 is not-secure and is strongly discouraged. + SSLv23 Alias for TLS. Deprecated in Python 3.6, use TLS. + TLS Negotiate highest possible version between client/server. + Can yield SSL. (Python 3.6+) + TLSv1 TLS 1.0 + TLSv1_1 TLS 1.1 (Python 3.4+) + TLSv1_2 TLS 1.2 (Python 3.4+) + TLS_SERVER Auto-negotiate the highest protocol version like TLS, + but only support server-side SSLSocket connections. + (Python 3.6+) + ============= ============ + + .. versionchanged:: 19.7 + The default value has been changed from ``ssl.PROTOCOL_TLSv1`` to + ``ssl.PROTOCOL_SSLv23``. + .. versionchanged:: 20.0 + This setting now accepts string names based on ``ssl.PROTOCOL_`` + constants. + """ + +class CertReqs(Setting): + name = "cert_reqs" + section = "SSL" + cli = ["--cert-reqs"] + validator = validate_pos_int + default = ssl.CERT_NONE + desc = """\ + Whether client certificate is required (see stdlib ssl module's) + """ + +class CACerts(Setting): + name = "ca_certs" + section = "SSL" + cli = ["--ca-certs"] + meta = "FILE" + validator = validate_string + default = None + desc = """\ + CA certificates file + """ + +class SuppressRaggedEOFs(Setting): + name = "suppress_ragged_eofs" + section = "SSL" + cli = ["--suppress-ragged-eofs"] + action = "store_true" + default = True + validator = validate_bool + desc = """\ + Suppress ragged EOFs (see stdlib ssl module's) + """ + +class DoHandshakeOnConnect(Setting): + name = "do_handshake_on_connect" + section = "SSL" + cli = ["--do-handshake-on-connect"] + validator = validate_bool + action = "store_true" + default = False + desc = """\ + Whether to perform SSL handshake on socket connect (see stdlib ssl module's) + """ + + +class Ciphers(Setting): + name = "ciphers" + section = "SSL" + cli = ["--ciphers"] + validator = validate_string + default = None + desc = """\ + SSL Cipher suite to use, in the format of an OpenSSL cipher list. + + By default we use the default cipher list from Python's ``ssl`` module, + which contains ciphers considered strong at the time of each Python + release. + + As a recommended alternative, the Open Web App Security Project (OWASP) + offers `a vetted set of strong cipher strings rated A+ to C- + `_. + OWASP provides details on user-agent compatibility at each security level. + + See the `OpenSSL Cipher List Format Documentation + `_ + for details on the format of an OpenSSL cipher list. + """ + + +class PasteGlobalConf(Setting): + name = "raw_paste_global_conf" + action = "append" + section = "Server Mechanics" + cli = ["--paste-global"] + meta = "CONF" + validator = validate_list_string + default = [] + + desc = """\ + Set a PasteDeploy global config variable in ``key=value`` form. + + The option can be specified multiple times. + + The variables are passed to the the PasteDeploy entrypoint. Example:: + + $ gunicorn -b 127.0.0.1:8000 --paste development.ini --paste-global FOO=1 --paste-global BAR=2 + + .. versionadded:: 19.7 + """ diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/debug.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/debug.py new file mode 100644 index 0000000..996fe1b --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/debug.py @@ -0,0 +1,69 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +"""The debug module contains utilities and functions for better +debugging Gunicorn.""" + +import sys +import linecache +import re +import inspect + +__all__ = ['spew', 'unspew'] + +_token_spliter = re.compile(r'\W+') + + +class Spew(object): + + def __init__(self, trace_names=None, show_values=True): + self.trace_names = trace_names + self.show_values = show_values + + def __call__(self, frame, event, arg): + if event == 'line': + lineno = frame.f_lineno + if '__file__' in frame.f_globals: + filename = frame.f_globals['__file__'] + if (filename.endswith('.pyc') or + filename.endswith('.pyo')): + filename = filename[:-1] + name = frame.f_globals['__name__'] + line = linecache.getline(filename, lineno) + else: + name = '[unknown]' + try: + src = inspect.getsourcelines(frame) + line = src[lineno] + except IOError: + line = 'Unknown code named [%s]. VM instruction #%d' % ( + frame.f_code.co_name, frame.f_lasti) + if self.trace_names is None or name in self.trace_names: + print('%s:%s: %s' % (name, lineno, line.rstrip())) + if not self.show_values: + return self + details = [] + tokens = _token_spliter.split(line) + for tok in tokens: + if tok in frame.f_globals: + details.append('%s=%r' % (tok, frame.f_globals[tok])) + if tok in frame.f_locals: + details.append('%s=%r' % (tok, frame.f_locals[tok])) + if details: + print("\t%s" % ' '.join(details)) + return self + + +def spew(trace_names=None, show_values=False): + """Install a trace hook which writes incredibly detailed logs + about what code is being executed to stdout. + """ + sys.settrace(Spew(trace_names, show_values)) + + +def unspew(): + """Remove the trace hook installed by spew. + """ + sys.settrace(None) diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/errors.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/errors.py new file mode 100644 index 0000000..727d336 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/errors.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +# We don't need to call super() in __init__ methods of our +# BaseException and Exception classes because we also define +# our own __str__ methods so there is no need to pass 'message' +# to the base class to get a meaningful output from 'str(exc)'. +# pylint: disable=super-init-not-called + + +# we inherit from BaseException here to make sure to not be caught +# at application level +class HaltServer(BaseException): + def __init__(self, reason, exit_status=1): + self.reason = reason + self.exit_status = exit_status + + def __str__(self): + return "" % (self.reason, self.exit_status) + + +class ConfigError(Exception): + """ Exception raised on config error """ + + +class AppImportError(Exception): + """ Exception raised when loading an application """ diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/glogging.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/glogging.py new file mode 100644 index 0000000..a096f96 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/glogging.py @@ -0,0 +1,463 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import base64 +import binascii +import time +import logging +logging.Logger.manager.emittedNoHandlerWarning = 1 +from logging.config import dictConfig +from logging.config import fileConfig +import os +import socket +import sys +import threading +import traceback + +from gunicorn import util + + +# syslog facility codes +SYSLOG_FACILITIES = { + "auth": 4, + "authpriv": 10, + "cron": 9, + "daemon": 3, + "ftp": 11, + "kern": 0, + "lpr": 6, + "mail": 2, + "news": 7, + "security": 4, # DEPRECATED + "syslog": 5, + "user": 1, + "uucp": 8, + "local0": 16, + "local1": 17, + "local2": 18, + "local3": 19, + "local4": 20, + "local5": 21, + "local6": 22, + "local7": 23 + } + + +CONFIG_DEFAULTS = dict( + version=1, + disable_existing_loggers=False, + + root={"level": "INFO", "handlers": ["console"]}, + loggers={ + "gunicorn.error": { + "level": "INFO", + "handlers": ["error_console"], + "propagate": True, + "qualname": "gunicorn.error" + }, + + "gunicorn.access": { + "level": "INFO", + "handlers": ["console"], + "propagate": True, + "qualname": "gunicorn.access" + } + }, + handlers={ + "console": { + "class": "logging.StreamHandler", + "formatter": "generic", + "stream": "ext://sys.stdout" + }, + "error_console": { + "class": "logging.StreamHandler", + "formatter": "generic", + "stream": "ext://sys.stderr" + }, + }, + formatters={ + "generic": { + "format": "%(asctime)s [%(process)d] [%(levelname)s] %(message)s", + "datefmt": "[%Y-%m-%d %H:%M:%S %z]", + "class": "logging.Formatter" + } + } +) + + +def loggers(): + """ get list of all loggers """ + root = logging.root + existing = root.manager.loggerDict.keys() + return [logging.getLogger(name) for name in existing] + + +class SafeAtoms(dict): + + def __init__(self, atoms): + dict.__init__(self) + for key, value in atoms.items(): + if isinstance(value, str): + self[key] = value.replace('"', '\\"') + else: + self[key] = value + + def __getitem__(self, k): + if k.startswith("{"): + kl = k.lower() + if kl in self: + return super().__getitem__(kl) + else: + return "-" + if k in self: + return super().__getitem__(k) + else: + return '-' + + +def parse_syslog_address(addr): + + # unix domain socket type depends on backend + # SysLogHandler will try both when given None + if addr.startswith("unix://"): + sock_type = None + + # set socket type only if explicitly requested + parts = addr.split("#", 1) + if len(parts) == 2: + addr = parts[0] + if parts[1] == "dgram": + sock_type = socket.SOCK_DGRAM + + return (sock_type, addr.split("unix://")[1]) + + if addr.startswith("udp://"): + addr = addr.split("udp://")[1] + socktype = socket.SOCK_DGRAM + elif addr.startswith("tcp://"): + addr = addr.split("tcp://")[1] + socktype = socket.SOCK_STREAM + else: + raise RuntimeError("invalid syslog address") + + if '[' in addr and ']' in addr: + host = addr.split(']')[0][1:].lower() + elif ':' in addr: + host = addr.split(':')[0].lower() + elif addr == "": + host = "localhost" + else: + host = addr.lower() + + addr = addr.split(']')[-1] + if ":" in addr: + port = addr.split(':', 1)[1] + if not port.isdigit(): + raise RuntimeError("%r is not a valid port number." % port) + port = int(port) + else: + port = 514 + + return (socktype, (host, port)) + + +class Logger(object): + + LOG_LEVELS = { + "critical": logging.CRITICAL, + "error": logging.ERROR, + "warning": logging.WARNING, + "info": logging.INFO, + "debug": logging.DEBUG + } + loglevel = logging.INFO + + error_fmt = r"%(asctime)s [%(process)d] [%(levelname)s] %(message)s" + datefmt = r"[%Y-%m-%d %H:%M:%S %z]" + + access_fmt = "%(message)s" + syslog_fmt = "[%(process)d] %(message)s" + + atoms_wrapper_class = SafeAtoms + + def __init__(self, cfg): + self.error_log = logging.getLogger("gunicorn.error") + self.error_log.propagate = False + self.access_log = logging.getLogger("gunicorn.access") + self.access_log.propagate = False + self.error_handlers = [] + self.access_handlers = [] + self.logfile = None + self.lock = threading.Lock() + self.cfg = cfg + self.setup(cfg) + + def setup(self, cfg): + self.loglevel = self.LOG_LEVELS.get(cfg.loglevel.lower(), logging.INFO) + self.error_log.setLevel(self.loglevel) + self.access_log.setLevel(logging.INFO) + + # set gunicorn.error handler + if self.cfg.capture_output and cfg.errorlog != "-": + for stream in sys.stdout, sys.stderr: + stream.flush() + + self.logfile = open(cfg.errorlog, 'a+') + os.dup2(self.logfile.fileno(), sys.stdout.fileno()) + os.dup2(self.logfile.fileno(), sys.stderr.fileno()) + + self._set_handler(self.error_log, cfg.errorlog, + logging.Formatter(self.error_fmt, self.datefmt)) + + # set gunicorn.access handler + if cfg.accesslog is not None: + self._set_handler(self.access_log, cfg.accesslog, + fmt=logging.Formatter(self.access_fmt), stream=sys.stdout) + + # set syslog handler + if cfg.syslog: + self._set_syslog_handler( + self.error_log, cfg, self.syslog_fmt, "error" + ) + if not cfg.disable_redirect_access_to_syslog: + self._set_syslog_handler( + self.access_log, cfg, self.syslog_fmt, "access" + ) + + if cfg.logconfig_dict: + config = CONFIG_DEFAULTS.copy() + config.update(cfg.logconfig_dict) + try: + dictConfig(config) + except ( + AttributeError, + ImportError, + ValueError, + TypeError + ) as exc: + raise RuntimeError(str(exc)) + elif cfg.logconfig: + if os.path.exists(cfg.logconfig): + defaults = CONFIG_DEFAULTS.copy() + defaults['__file__'] = cfg.logconfig + defaults['here'] = os.path.dirname(cfg.logconfig) + fileConfig(cfg.logconfig, defaults=defaults, + disable_existing_loggers=False) + else: + msg = "Error: log config '%s' not found" + raise RuntimeError(msg % cfg.logconfig) + + def critical(self, msg, *args, **kwargs): + self.error_log.critical(msg, *args, **kwargs) + + def error(self, msg, *args, **kwargs): + self.error_log.error(msg, *args, **kwargs) + + def warning(self, msg, *args, **kwargs): + self.error_log.warning(msg, *args, **kwargs) + + def info(self, msg, *args, **kwargs): + self.error_log.info(msg, *args, **kwargs) + + def debug(self, msg, *args, **kwargs): + self.error_log.debug(msg, *args, **kwargs) + + def exception(self, msg, *args, **kwargs): + self.error_log.exception(msg, *args, **kwargs) + + def log(self, lvl, msg, *args, **kwargs): + if isinstance(lvl, str): + lvl = self.LOG_LEVELS.get(lvl.lower(), logging.INFO) + self.error_log.log(lvl, msg, *args, **kwargs) + + def atoms(self, resp, req, environ, request_time): + """ Gets atoms for log formating. + """ + status = resp.status + if isinstance(status, str): + status = status.split(None, 1)[0] + atoms = { + 'h': environ.get('REMOTE_ADDR', '-'), + 'l': '-', + 'u': self._get_user(environ) or '-', + 't': self.now(), + 'r': "%s %s %s" % (environ['REQUEST_METHOD'], + environ['RAW_URI'], environ["SERVER_PROTOCOL"]), + 's': status, + 'm': environ.get('REQUEST_METHOD'), + 'U': environ.get('PATH_INFO'), + 'q': environ.get('QUERY_STRING'), + 'H': environ.get('SERVER_PROTOCOL'), + 'b': getattr(resp, 'sent', None) is not None and str(resp.sent) or '-', + 'B': getattr(resp, 'sent', None), + 'f': environ.get('HTTP_REFERER', '-'), + 'a': environ.get('HTTP_USER_AGENT', '-'), + 'T': request_time.seconds, + 'D': (request_time.seconds*1000000) + request_time.microseconds, + 'L': "%d.%06d" % (request_time.seconds, request_time.microseconds), + 'p': "<%s>" % os.getpid() + } + + # add request headers + if hasattr(req, 'headers'): + req_headers = req.headers + else: + req_headers = req + + if hasattr(req_headers, "items"): + req_headers = req_headers.items() + + atoms.update({"{%s}i" % k.lower(): v for k, v in req_headers}) + + resp_headers = resp.headers + if hasattr(resp_headers, "items"): + resp_headers = resp_headers.items() + + # add response headers + atoms.update({"{%s}o" % k.lower(): v for k, v in resp_headers}) + + # add environ variables + environ_variables = environ.items() + atoms.update({"{%s}e" % k.lower(): v for k, v in environ_variables}) + + return atoms + + def access(self, resp, req, environ, request_time): + """ See http://httpd.apache.org/docs/2.0/logs.html#combined + for format details + """ + + if not (self.cfg.accesslog or self.cfg.logconfig or + self.cfg.logconfig_dict or + (self.cfg.syslog and not self.cfg.disable_redirect_access_to_syslog)): + return + + # wrap atoms: + # - make sure atoms will be test case insensitively + # - if atom doesn't exist replace it by '-' + safe_atoms = self.atoms_wrapper_class(self.atoms(resp, req, environ, + request_time)) + + try: + self.access_log.info(self.cfg.access_log_format, safe_atoms) + except: + self.error(traceback.format_exc()) + + def now(self): + """ return date in Apache Common Log Format """ + return time.strftime('[%d/%b/%Y:%H:%M:%S %z]') + + def reopen_files(self): + if self.cfg.capture_output and self.cfg.errorlog != "-": + for stream in sys.stdout, sys.stderr: + stream.flush() + + with self.lock: + if self.logfile is not None: + self.logfile.close() + self.logfile = open(self.cfg.errorlog, 'a+') + os.dup2(self.logfile.fileno(), sys.stdout.fileno()) + os.dup2(self.logfile.fileno(), sys.stderr.fileno()) + + + for log in loggers(): + for handler in log.handlers: + if isinstance(handler, logging.FileHandler): + handler.acquire() + try: + if handler.stream: + handler.close() + handler.stream = handler._open() + finally: + handler.release() + + def close_on_exec(self): + for log in loggers(): + for handler in log.handlers: + if isinstance(handler, logging.FileHandler): + handler.acquire() + try: + if handler.stream: + util.close_on_exec(handler.stream.fileno()) + finally: + handler.release() + + def _get_gunicorn_handler(self, log): + for h in log.handlers: + if getattr(h, "_gunicorn", False): + return h + + def _set_handler(self, log, output, fmt, stream=None): + # remove previous gunicorn log handler + h = self._get_gunicorn_handler(log) + if h: + log.handlers.remove(h) + + if output is not None: + if output == "-": + h = logging.StreamHandler(stream) + else: + util.check_is_writeable(output) + h = logging.FileHandler(output) + # make sure the user can reopen the file + try: + os.chown(h.baseFilename, self.cfg.user, self.cfg.group) + except OSError: + # it's probably OK there, we assume the user has given + # /dev/null as a parameter. + pass + + h.setFormatter(fmt) + h._gunicorn = True + log.addHandler(h) + + def _set_syslog_handler(self, log, cfg, fmt, name): + # setup format + if not cfg.syslog_prefix: + prefix = cfg.proc_name.replace(":", ".") + else: + prefix = cfg.syslog_prefix + + prefix = "gunicorn.%s.%s" % (prefix, name) + + # set format + fmt = logging.Formatter(r"%s: %s" % (prefix, fmt)) + + # syslog facility + try: + facility = SYSLOG_FACILITIES[cfg.syslog_facility.lower()] + except KeyError: + raise RuntimeError("unknown facility name") + + # parse syslog address + socktype, addr = parse_syslog_address(cfg.syslog_addr) + + # finally setup the syslog handler + h = logging.handlers.SysLogHandler(address=addr, + facility=facility, socktype=socktype) + + h.setFormatter(fmt) + h._gunicorn = True + log.addHandler(h) + + def _get_user(self, environ): + user = None + http_auth = environ.get("HTTP_AUTHORIZATION") + if http_auth and http_auth.lower().startswith('basic'): + auth = http_auth.split(" ", 1) + if len(auth) == 2: + try: + # b64decode doesn't accept unicode in Python < 3.3 + # so we need to convert it to a byte string + auth = base64.b64decode(auth[1].strip().encode('utf-8')) + # b64decode returns a byte string + auth = auth.decode('utf-8') + auth = auth.split(":", 1) + except (TypeError, binascii.Error, UnicodeDecodeError) as exc: + self.debug("Couldn't get username: %s", exc) + return user + if len(auth) == 2: + user = auth[0] + return user diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__init__.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__init__.py new file mode 100644 index 0000000..1da6f3e --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__init__.py @@ -0,0 +1,9 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +from gunicorn.http.message import Message, Request +from gunicorn.http.parser import RequestParser + +__all__ = ['Message', 'Request', 'RequestParser'] diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/__init__.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efd16e2491d0981c4c701ddef576964d30209b54 GIT binary patch literal 312 zcmY+7v1-FG6h$T3u|tWWL-P?X#BMu>P`bB-bQ2U|BH;)mN0H>ApVWWp(p77x{z9j| zM-oCG=yD&r@7$-Vx*{;24_|L{O2{`Z=gGi4!V9+`l1OTZrJP#E8O5EM%;r1?pUGTK z`ixIx@k;9Q2lAw5seD!;biGRDMjb{KVog(Zvg^(V$0DDDywnAs_v4_qdp|V0 z7+qtJh)a;){13Pz2+va~L}!c;AH)~PMEPB|(Yn@Yx6ng~@V~IzJ9!x0eS0Qd40g6c Z=s`yz8uy;2OS_k&Q7dExY`La0_6K1rQAhv) literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/body.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/body.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4cdaceb7e7f4e3a6ba5941d157e597670f3cbb37 GIT binary patch literal 6394 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 bs5Ru?3nuP-k+7adjPitPeW!K0^~8Sw?$z($ literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/errors.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/errors.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39a212ce01d07df66aa8440325bd15549bf74bfd GIT binary patch literal 5842 zcmbW5TXWM!6vrh?@g<29Cm}bIfPkUYbRaE#=nQ43r-2rxU@|1rp&1y}c$HYKEjcTh zONO`d0Xox9(eKiizUsC86n*OXuXYtV2#+nztmLzj&;ECRyJs)oR;$w*U4PyB`^DuM zP5TFix=i}fpcMQ|x9>HkG5tLyNBhk<(8(?^gKWbokZq7{vMI8s9Gz^F>>?|XT@v;b z*=1HCyCUo&+0$%>>=|K~$ev|Yva7-_lRd}g$(|SfD`eN$0@(|~o+f*dEs?z>zMmoc z99t%PS=h5=udr3JSA|_AdyTD=y)NuIvd^;(vNwc1&o=k8`c|82np`^lYETMh>E>t$ zI@1mcOsDS((cEr}2hROBZKof)zSpc9QQ5Y=R?o5RXxg@WJ{xrLd)Bs(2d!@W=1+}J zkuP!k@Ah`s>u>kn{ted)!dAC?qu2hN9S{0nY#$9gx9xN9^hYNQ``ZrZJ`Zm8-*QN+ zLRx`tWnI`q+6~HY;DZZvOSBgSGyTAbSsj?7Hl=8~=|A?lbFUS)nr*nmg(uPur2xI; zo&HXIZ3Sf(nkOqw-|CT2i;+^Rbr?GQwsn=)bx}M$D)j%eDoVB;gxt25>75d> zI3z;6MxCZO3g>7%j^58vZBFAN?Nks%{dkFP3zPzUTh^xyku$^r{u=mXlWqwIofY0| zM1eTalg15IuNW;p^j@{PE_>=651b%;V>#P&{fVfi>TUpD1&%SFX|^7AC^Bcp)Kjdda%F0YmpGt#OhL2Bq&J91|`}V-Bm$4 zpQ%T{niv&^@H%|QsLCcsPHt4^hNV4r!j8|fVP%b+Vo&@*;Q`MqJXatXJxJ3}RKv>7 z5tleIp4A~du?h(WB1VAuB&B6DtM;TNADVgcd>P&)8iOMzHySmH&;fsRctFv4d@!X~ z@jnz91gLRjaUJQN#+i8$TmniXxs;=tchW$;1ka<9pT8r@@hOH-=x&6 ze^B$>K@5wFui-iwEy&5uq$ZW^bOzq9d+y2jNFoz!BNe|^NkrE0xCg0{iE4$Utcj7R z;bpZU*9u6lgn{x$43F-ReCJ77V!1a#y9o}=jR_ODw z2T5eoGPS3OU=fl<H!1Daiy7rtu_pV7+P&R_qla#;< z9~GF7*c$o%0sa$W$jMEt_Q>tIVR{*DkULy>qTBCK8Zp#lV* zs8iQUl#KxR3)j7ebSN&EkvbmOYj>QUqrw;?P8MPh*%s0L$tDR ip6ZCnIa^e|6CbDE#r7}2{8BS(T} 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 CZ|=hY literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/parser.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/parser.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ffd126052959e0100211f3ba2fa8fd2c259e9d8 GIT binary patch literal 1307 zcmZuwOK;Oa5Z+fDH%-z|iHJv$xFJh4r5r#)2u0<9xI~BwAz4C}>)o~qj-BkTQH#ul z^oO)Z{tFkbd*#%>z=;{V=|k#D^Lb`>JhMCB%uc7%BCvix|MR8WAmlF^%OyY=f*1rz zBu&YbhLobtQa0rwpNddW@{UL@#R-u@H5NSdz-~wnY)^S$H)V5|1pYZhApv#Gk7`~h zV*}>8yLs|e*-x2Pu~gc%-&>`ZR)YS^#XuQ?n5O`WgjAA{Ng8s=BtIdckU}=#3wdP| zzK|L6Qq1eT53x2%j}i|5;=(V=TM+XCprj> zNdlqy$O)~IZ<<1kpy_zBf8d&jv5BqK8Z$V*xOkh!YC17h=D@9JHII_K$ZWu!Fe=^G zO+58XUg$*qBDxFazgJs!I@_9!XPe{9*f>o$r^z!pFJ{|Y2Sqkca-Cf%ht`5`_0YlW z*!fX3&c-&1Fp_Bl5bDtuZL=2j`1iHCB!i__f-k^@UzDmec;ylwN=Ma=0;(}mrPr_q zW|a$gi=z8r8Dxsk>lv!E%M5r9omOW!0;MDqqWg%a^b9o17UU-sA9i;TC;U`MdPaZH zqkc*C@aEq9>1T)_$OMRaNf;1Rl2Z?Snjk(% zbC?&YjFL1r%5`>aKEs}j?Ksbz*vsWHQXWga3f``Tbb@beOvRvH!BDKKk`pqv@h!E= z)DiHq0iLE0Kv)kL@n{$LS?68ahp%_NeziaJF>sp2Qx!$76-Cor7AflOD4G{>TAyf) zsCx)^5bgmuff24<1Y1HQa~gTTXBz~c3Ffc*++VNu6WF?3SfU|_!O+X`Qyj()M~u17 z#Y|sJTF}tg3;F@VLj+{KzFd|43aWcNg41n~s(E~-(H;eUcz4<718naBRNKS{stOkN oZ=PMw8ID~&Y+k-MQHiZyQ-!>(2F`z7m-3B=7eHv!9`8N*4}mNl{{R30 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/unreader.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/unreader.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27445c834f0454ab387c591de9001d04d127c26f GIT binary patch literal 2368 zcmaJ@&2Jk;6rY*hwbxD@(vS*TzRZUTmS_Tq3sD7C+XyNoa|j4z39U9elhpBg?aYo# zVr?%?Q4#+D*W}3mz+Zs4aGfisp1E=2_h!9zQU%7EH}mG>y*Kao-do>kwVDj=kB|QR z{+Bvqe-TqPACueY`8^QHBu`nd9C?p_&ZLmu6DB<+PQ0E6-j@ORKzZPO@HJTnUw3>U z`3~!Z&mf6)6QWh~Fu9GMZ-6M))==lnWVW<3z6)X~x;STS1JS+MmTfcK`RDS;}>+MeVI^6oXO80(c z8g5|!+}bq5@#eTczS+-m6Q}9TVe)}IoQyx*+@ECqWTdmjSM0XBi8BZX=z4(e)RN;0s2nu(b%UAVCnCRY0L2M^%x61W z7{x&74e9OBX)$1WOR`72UYKx;iRxZ zsDCQh=@NFm0+NsJRQC!F4ZqL!{KC(Fb32#GAq$oZ|BQ2X`17{_96X&1&gm=91oWC8 z#WhA}i$KC!;^1t*JH3(jr>Z@Ubv#r?>Gp7voA$11$633dnf6Gx(^0m+p$V_Q(OIWu zoBiB{NtP(<;goHBeLPkUB~1>d*ir*4M!5}lwzt2Gw!8PNZ&aGva9^2+aXL|&5wvm`g-z;loj?-!h$>LOQkos&9&^MPK) z9Zhkm*N9vN>4-9fuh9bK-MKifl?g@9$Vo5bt9<&x+_rL;vbj#_mI19Ovdt(Oj^rez z`EnE;PU5uO(G8MLj@8$Ryh3E5(ak7*G(EG0o)ZTzd7;;AyVV2>^X4o9m)`)HSFPGp zwuhuZU2LFsxq8_1pTccDs#bNovNK8s%2bbd#@dV}ggZ4FNjr@>8A(NeN*84lm9Ij8 zdR0;IZIDmKO1qaKJ|NlFhes~OJ6`G6w;-k07{*6Yxy)@Nijp+W^C()l+DX_VtyB;g z;-JQ-FI_bC@|s1a-ldCF=gN2h6=ziIsm^LLz#=A-hx%RmNQhT4=+}t6PGpX(ZOtB+AhD_k60%VH4xMxWzk%5&=q{*2z7l9!Nzmtwo<%LE zTNSttTKX)7i_g*=+Q2T~N3p1Yy^u6>Okaky1*S$6sH_)0OZrWmnBj@s*R%AnAu;i8 zs;Y-9!j&F>4}F#*O+LMP-jK^-BR@FUD7gr>yh)$u4}jRW~zY`GUwo`!tc*R+DzA!uC@vbE9ffl7=^Z5IOW$U@#CKWuobEGnN; NepH2_w)*~R^ItoD+tL64 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/wsgi.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/__pycache__/wsgi.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9266b0b3a6b80a4a7d2889c1aba02c8d2a2c498a GIT binary patch literal 9023 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 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/body.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/body.py new file mode 100644 index 0000000..afde368 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/body.py @@ -0,0 +1,262 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import io +import sys + +from gunicorn.http.errors import (NoMoreData, ChunkMissingTerminator, + InvalidChunkSize) + + +class ChunkedReader(object): + def __init__(self, req, unreader): + self.req = req + self.parser = self.parse_chunked(unreader) + self.buf = io.BytesIO() + + def read(self, size): + if not isinstance(size, int): + raise TypeError("size must be an integral type") + if size < 0: + raise ValueError("Size must be positive.") + if size == 0: + return b"" + + if self.parser: + while self.buf.tell() < size: + try: + self.buf.write(next(self.parser)) + except StopIteration: + self.parser = None + break + + data = self.buf.getvalue() + ret, rest = data[:size], data[size:] + self.buf = io.BytesIO() + self.buf.write(rest) + return ret + + def parse_trailers(self, unreader, data): + buf = io.BytesIO() + buf.write(data) + + idx = buf.getvalue().find(b"\r\n\r\n") + done = buf.getvalue()[:2] == b"\r\n" + while idx < 0 and not done: + self.get_data(unreader, buf) + idx = buf.getvalue().find(b"\r\n\r\n") + done = buf.getvalue()[:2] == b"\r\n" + if done: + unreader.unread(buf.getvalue()[2:]) + return b"" + self.req.trailers = self.req.parse_headers(buf.getvalue()[:idx]) + unreader.unread(buf.getvalue()[idx + 4:]) + + def parse_chunked(self, unreader): + (size, rest) = self.parse_chunk_size(unreader) + while size > 0: + while size > len(rest): + size -= len(rest) + yield rest + rest = unreader.read() + if not rest: + raise NoMoreData() + yield rest[:size] + # Remove \r\n after chunk + rest = rest[size:] + while len(rest) < 2: + rest += unreader.read() + if rest[:2] != b'\r\n': + raise ChunkMissingTerminator(rest[:2]) + (size, rest) = self.parse_chunk_size(unreader, data=rest[2:]) + + def parse_chunk_size(self, unreader, data=None): + buf = io.BytesIO() + if data is not None: + buf.write(data) + + idx = buf.getvalue().find(b"\r\n") + while idx < 0: + self.get_data(unreader, buf) + idx = buf.getvalue().find(b"\r\n") + + data = buf.getvalue() + line, rest_chunk = data[:idx], data[idx + 2:] + + chunk_size = line.split(b";", 1)[0].strip() + try: + chunk_size = int(chunk_size, 16) + except ValueError: + raise InvalidChunkSize(chunk_size) + + if chunk_size == 0: + try: + self.parse_trailers(unreader, rest_chunk) + except NoMoreData: + pass + return (0, None) + return (chunk_size, rest_chunk) + + def get_data(self, unreader, buf): + data = unreader.read() + if not data: + raise NoMoreData() + buf.write(data) + + +class LengthReader(object): + def __init__(self, unreader, length): + self.unreader = unreader + self.length = length + + def read(self, size): + if not isinstance(size, int): + raise TypeError("size must be an integral type") + + size = min(self.length, size) + if size < 0: + raise ValueError("Size must be positive.") + if size == 0: + return b"" + + buf = io.BytesIO() + data = self.unreader.read() + while data: + buf.write(data) + if buf.tell() >= size: + break + data = self.unreader.read() + + buf = buf.getvalue() + ret, rest = buf[:size], buf[size:] + self.unreader.unread(rest) + self.length -= size + return ret + + +class EOFReader(object): + def __init__(self, unreader): + self.unreader = unreader + self.buf = io.BytesIO() + self.finished = False + + def read(self, size): + if not isinstance(size, int): + raise TypeError("size must be an integral type") + if size < 0: + raise ValueError("Size must be positive.") + if size == 0: + return b"" + + if self.finished: + data = self.buf.getvalue() + ret, rest = data[:size], data[size:] + self.buf = io.BytesIO() + self.buf.write(rest) + return ret + + data = self.unreader.read() + while data: + self.buf.write(data) + if self.buf.tell() > size: + break + data = self.unreader.read() + + if not data: + self.finished = True + + data = self.buf.getvalue() + ret, rest = data[:size], data[size:] + self.buf = io.BytesIO() + self.buf.write(rest) + return ret + + +class Body(object): + def __init__(self, reader): + self.reader = reader + self.buf = io.BytesIO() + + def __iter__(self): + return self + + def __next__(self): + ret = self.readline() + if not ret: + raise StopIteration() + return ret + + next = __next__ + + def getsize(self, size): + if size is None: + return sys.maxsize + elif not isinstance(size, int): + raise TypeError("size must be an integral type") + elif size < 0: + return sys.maxsize + return size + + def read(self, size=None): + size = self.getsize(size) + if size == 0: + return b"" + + if size < self.buf.tell(): + data = self.buf.getvalue() + ret, rest = data[:size], data[size:] + self.buf = io.BytesIO() + self.buf.write(rest) + return ret + + while size > self.buf.tell(): + data = self.reader.read(1024) + if not data: + break + self.buf.write(data) + + data = self.buf.getvalue() + ret, rest = data[:size], data[size:] + self.buf = io.BytesIO() + self.buf.write(rest) + return ret + + def readline(self, size=None): + size = self.getsize(size) + if size == 0: + return b"" + + data = self.buf.getvalue() + self.buf = io.BytesIO() + + ret = [] + while 1: + idx = data.find(b"\n", 0, size) + idx = idx + 1 if idx >= 0 else size if len(data) >= size else 0 + if idx: + ret.append(data[:idx]) + self.buf.write(data[idx:]) + break + + ret.append(data) + size -= len(data) + data = self.reader.read(min(1024, size)) + if not data: + break + + return b"".join(ret) + + def readlines(self, size=None): + ret = [] + data = self.read() + while data: + pos = data.find(b"\n") + if pos < 0: + ret.append(data) + data = b"" + else: + line, data = data[:pos + 1], data[pos + 1:] + ret.append(line) + return ret diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/errors.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/errors.py new file mode 100644 index 0000000..7839ef0 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/errors.py @@ -0,0 +1,120 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +# We don't need to call super() in __init__ methods of our +# BaseException and Exception classes because we also define +# our own __str__ methods so there is no need to pass 'message' +# to the base class to get a meaningful output from 'str(exc)'. +# pylint: disable=super-init-not-called + + +class ParseException(Exception): + pass + + +class NoMoreData(IOError): + def __init__(self, buf=None): + self.buf = buf + + def __str__(self): + return "No more data after: %r" % self.buf + + +class InvalidRequestLine(ParseException): + def __init__(self, req): + self.req = req + self.code = 400 + + def __str__(self): + return "Invalid HTTP request line: %r" % self.req + + +class InvalidRequestMethod(ParseException): + def __init__(self, method): + self.method = method + + def __str__(self): + return "Invalid HTTP method: %r" % self.method + + +class InvalidHTTPVersion(ParseException): + def __init__(self, version): + self.version = version + + def __str__(self): + return "Invalid HTTP Version: %r" % self.version + + +class InvalidHeader(ParseException): + def __init__(self, hdr, req=None): + self.hdr = hdr + self.req = req + + def __str__(self): + return "Invalid HTTP Header: %r" % self.hdr + + +class InvalidHeaderName(ParseException): + def __init__(self, hdr): + self.hdr = hdr + + def __str__(self): + return "Invalid HTTP header name: %r" % self.hdr + + +class InvalidChunkSize(IOError): + def __init__(self, data): + self.data = data + + def __str__(self): + return "Invalid chunk size: %r" % self.data + + +class ChunkMissingTerminator(IOError): + def __init__(self, term): + self.term = term + + def __str__(self): + return "Invalid chunk terminator is not '\\r\\n': %r" % self.term + + +class LimitRequestLine(ParseException): + def __init__(self, size, max_size): + self.size = size + self.max_size = max_size + + def __str__(self): + return "Request Line is too large (%s > %s)" % (self.size, self.max_size) + + +class LimitRequestHeaders(ParseException): + def __init__(self, msg): + self.msg = msg + + def __str__(self): + return self.msg + + +class InvalidProxyLine(ParseException): + def __init__(self, line): + self.line = line + self.code = 400 + + def __str__(self): + return "Invalid PROXY line: %r" % self.line + + +class ForbiddenProxyRequest(ParseException): + def __init__(self, host): + self.host = host + self.code = 403 + + def __str__(self): + return "Proxy request from %r not allowed" % self.host + + +class InvalidSchemeHeaders(ParseException): + def __str__(self): + return "Contradictory scheme headers" diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/message.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/message.py new file mode 100644 index 0000000..4040c7a --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/message.py @@ -0,0 +1,362 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import io +import re +import socket +from errno import ENOTCONN + +from gunicorn.http.unreader import SocketUnreader +from gunicorn.http.body import ChunkedReader, LengthReader, EOFReader, Body +from gunicorn.http.errors import (InvalidHeader, InvalidHeaderName, NoMoreData, + InvalidRequestLine, InvalidRequestMethod, InvalidHTTPVersion, + LimitRequestLine, LimitRequestHeaders) +from gunicorn.http.errors import InvalidProxyLine, ForbiddenProxyRequest +from gunicorn.http.errors import InvalidSchemeHeaders +from gunicorn.util import bytes_to_str, split_request_uri + +MAX_REQUEST_LINE = 8190 +MAX_HEADERS = 32768 +DEFAULT_MAX_HEADERFIELD_SIZE = 8190 + +HEADER_RE = re.compile(r"[\x00-\x1F\x7F()<>@,;:\[\]={} \t\\\"]") +METH_RE = re.compile(r"[A-Z0-9$-_.]{3,20}") +VERSION_RE = re.compile(r"HTTP/(\d+)\.(\d+)") + + +class Message(object): + def __init__(self, cfg, unreader): + self.cfg = cfg + self.unreader = unreader + self.version = None + self.headers = [] + self.trailers = [] + self.body = None + self.scheme = "https" if cfg.is_ssl else "http" + + # set headers limits + self.limit_request_fields = cfg.limit_request_fields + if (self.limit_request_fields <= 0 + or self.limit_request_fields > MAX_HEADERS): + self.limit_request_fields = MAX_HEADERS + self.limit_request_field_size = cfg.limit_request_field_size + if self.limit_request_field_size < 0: + self.limit_request_field_size = DEFAULT_MAX_HEADERFIELD_SIZE + + # set max header buffer size + max_header_field_size = self.limit_request_field_size or DEFAULT_MAX_HEADERFIELD_SIZE + self.max_buffer_headers = self.limit_request_fields * \ + (max_header_field_size + 2) + 4 + + unused = self.parse(self.unreader) + self.unreader.unread(unused) + self.set_body_reader() + + def parse(self, unreader): + raise NotImplementedError() + + def parse_headers(self, data): + cfg = self.cfg + headers = [] + + # Split lines on \r\n keeping the \r\n on each line + lines = [bytes_to_str(line) + "\r\n" for line in data.split(b"\r\n")] + + # handle scheme headers + scheme_header = False + secure_scheme_headers = {} + if '*' in cfg.forwarded_allow_ips: + secure_scheme_headers = cfg.secure_scheme_headers + elif isinstance(self.unreader, SocketUnreader): + remote_addr = self.unreader.sock.getpeername() + if self.unreader.sock.family in (socket.AF_INET, socket.AF_INET6): + remote_host = remote_addr[0] + if remote_host in cfg.forwarded_allow_ips: + secure_scheme_headers = cfg.secure_scheme_headers + elif self.unreader.sock.family == socket.AF_UNIX: + secure_scheme_headers = cfg.secure_scheme_headers + + # Parse headers into key/value pairs paying attention + # to continuation lines. + while lines: + if len(headers) >= self.limit_request_fields: + raise LimitRequestHeaders("limit request headers fields") + + # Parse initial header name : value pair. + curr = lines.pop(0) + header_length = len(curr) + if curr.find(":") < 0: + raise InvalidHeader(curr.strip()) + name, value = curr.split(":", 1) + name = name.rstrip(" \t").upper() + if HEADER_RE.search(name): + raise InvalidHeaderName(name) + + name, value = name.strip(), [value.lstrip()] + + # Consume value continuation lines + while lines and lines[0].startswith((" ", "\t")): + curr = lines.pop(0) + header_length += len(curr) + if header_length > self.limit_request_field_size > 0: + raise LimitRequestHeaders("limit request headers " + + "fields size") + value.append(curr) + value = ''.join(value).rstrip() + + if header_length > self.limit_request_field_size > 0: + raise LimitRequestHeaders("limit request headers fields size") + + if name in secure_scheme_headers: + secure = value == secure_scheme_headers[name] + scheme = "https" if secure else "http" + if scheme_header: + if scheme != self.scheme: + raise InvalidSchemeHeaders() + else: + scheme_header = True + self.scheme = scheme + + headers.append((name, value)) + + return headers + + def set_body_reader(self): + chunked = False + content_length = None + for (name, value) in self.headers: + if name == "CONTENT-LENGTH": + content_length = value + elif name == "TRANSFER-ENCODING": + chunked = value.lower() == "chunked" + elif name == "SEC-WEBSOCKET-KEY1": + content_length = 8 + + if chunked: + self.body = Body(ChunkedReader(self, self.unreader)) + elif content_length is not None: + try: + content_length = int(content_length) + except ValueError: + raise InvalidHeader("CONTENT-LENGTH", req=self) + + if content_length < 0: + raise InvalidHeader("CONTENT-LENGTH", req=self) + + self.body = Body(LengthReader(self.unreader, content_length)) + else: + self.body = Body(EOFReader(self.unreader)) + + def should_close(self): + for (h, v) in self.headers: + if h == "CONNECTION": + v = v.lower().strip() + if v == "close": + return True + elif v == "keep-alive": + return False + break + return self.version <= (1, 0) + + +class Request(Message): + def __init__(self, cfg, unreader, req_number=1): + self.method = None + self.uri = None + self.path = None + self.query = None + self.fragment = None + + # get max request line size + self.limit_request_line = cfg.limit_request_line + if (self.limit_request_line < 0 + or self.limit_request_line >= MAX_REQUEST_LINE): + self.limit_request_line = MAX_REQUEST_LINE + + self.req_number = req_number + self.proxy_protocol_info = None + super().__init__(cfg, unreader) + + def get_data(self, unreader, buf, stop=False): + data = unreader.read() + if not data: + if stop: + raise StopIteration() + raise NoMoreData(buf.getvalue()) + buf.write(data) + + def parse(self, unreader): + buf = io.BytesIO() + self.get_data(unreader, buf, stop=True) + + # get request line + line, rbuf = self.read_line(unreader, buf, self.limit_request_line) + + # proxy protocol + if self.proxy_protocol(bytes_to_str(line)): + # get next request line + buf = io.BytesIO() + buf.write(rbuf) + line, rbuf = self.read_line(unreader, buf, self.limit_request_line) + + self.parse_request_line(line) + buf = io.BytesIO() + buf.write(rbuf) + + # Headers + data = buf.getvalue() + idx = data.find(b"\r\n\r\n") + + done = data[:2] == b"\r\n" + while True: + idx = data.find(b"\r\n\r\n") + done = data[:2] == b"\r\n" + + if idx < 0 and not done: + self.get_data(unreader, buf) + data = buf.getvalue() + if len(data) > self.max_buffer_headers: + raise LimitRequestHeaders("max buffer headers") + else: + break + + if done: + self.unreader.unread(data[2:]) + return b"" + + self.headers = self.parse_headers(data[:idx]) + + ret = data[idx + 4:] + buf = None + return ret + + def read_line(self, unreader, buf, limit=0): + data = buf.getvalue() + + while True: + idx = data.find(b"\r\n") + if idx >= 0: + # check if the request line is too large + if idx > limit > 0: + raise LimitRequestLine(idx, limit) + break + if len(data) - 2 > limit > 0: + raise LimitRequestLine(len(data), limit) + self.get_data(unreader, buf) + data = buf.getvalue() + + return (data[:idx], # request line, + data[idx + 2:]) # residue in the buffer, skip \r\n + + def proxy_protocol(self, line): + """\ + Detect, check and parse proxy protocol. + + :raises: ForbiddenProxyRequest, InvalidProxyLine. + :return: True for proxy protocol line else False + """ + if not self.cfg.proxy_protocol: + return False + + if self.req_number != 1: + return False + + if not line.startswith("PROXY"): + return False + + self.proxy_protocol_access_check() + self.parse_proxy_protocol(line) + + return True + + def proxy_protocol_access_check(self): + # check in allow list + if isinstance(self.unreader, SocketUnreader): + try: + remote_host = self.unreader.sock.getpeername()[0] + except socket.error as e: + if e.args[0] == ENOTCONN: + raise ForbiddenProxyRequest("UNKNOW") + raise + if ("*" not in self.cfg.proxy_allow_ips and + remote_host not in self.cfg.proxy_allow_ips): + raise ForbiddenProxyRequest(remote_host) + + def parse_proxy_protocol(self, line): + bits = line.split() + + if len(bits) != 6: + raise InvalidProxyLine(line) + + # Extract data + proto = bits[1] + s_addr = bits[2] + d_addr = bits[3] + + # Validation + if proto not in ["TCP4", "TCP6"]: + raise InvalidProxyLine("protocol '%s' not supported" % proto) + if proto == "TCP4": + try: + socket.inet_pton(socket.AF_INET, s_addr) + socket.inet_pton(socket.AF_INET, d_addr) + except socket.error: + raise InvalidProxyLine(line) + elif proto == "TCP6": + try: + socket.inet_pton(socket.AF_INET6, s_addr) + socket.inet_pton(socket.AF_INET6, d_addr) + except socket.error: + raise InvalidProxyLine(line) + + try: + s_port = int(bits[4]) + d_port = int(bits[5]) + except ValueError: + raise InvalidProxyLine("invalid port %s" % line) + + if not ((0 <= s_port <= 65535) and (0 <= d_port <= 65535)): + raise InvalidProxyLine("invalid port %s" % line) + + # Set data + self.proxy_protocol_info = { + "proxy_protocol": proto, + "client_addr": s_addr, + "client_port": s_port, + "proxy_addr": d_addr, + "proxy_port": d_port + } + + def parse_request_line(self, line_bytes): + bits = [bytes_to_str(bit) for bit in line_bytes.split(None, 2)] + if len(bits) != 3: + raise InvalidRequestLine(bytes_to_str(line_bytes)) + + # Method + if not METH_RE.match(bits[0]): + raise InvalidRequestMethod(bits[0]) + self.method = bits[0].upper() + + # URI + self.uri = bits[1] + + try: + parts = split_request_uri(self.uri) + except ValueError: + raise InvalidRequestLine(bytes_to_str(line_bytes)) + self.path = parts.path or "" + self.query = parts.query or "" + self.fragment = parts.fragment or "" + + # Version + match = VERSION_RE.match(bits[2]) + if match is None: + raise InvalidHTTPVersion(bits[2]) + self.version = (int(match.group(1)), int(match.group(2))) + + def set_body_reader(self): + super().set_body_reader() + if isinstance(self.body.reader, EOFReader): + self.body = Body(LengthReader(self.unreader, 0)) diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/parser.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/parser.py new file mode 100644 index 0000000..a4a0f1e --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/parser.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +from gunicorn.http.message import Request +from gunicorn.http.unreader import SocketUnreader, IterUnreader + + +class Parser(object): + + mesg_class = None + + def __init__(self, cfg, source): + self.cfg = cfg + if hasattr(source, "recv"): + self.unreader = SocketUnreader(source) + else: + self.unreader = IterUnreader(source) + self.mesg = None + + # request counter (for keepalive connetions) + self.req_count = 0 + + def __iter__(self): + return self + + def __next__(self): + # Stop if HTTP dictates a stop. + if self.mesg and self.mesg.should_close(): + raise StopIteration() + + # Discard any unread body of the previous message + if self.mesg: + data = self.mesg.body.read(8192) + while data: + data = self.mesg.body.read(8192) + + # Parse the next request + self.req_count += 1 + self.mesg = self.mesg_class(self.cfg, self.unreader, self.req_count) + if not self.mesg: + raise StopIteration() + return self.mesg + + next = __next__ + + +class RequestParser(Parser): + + mesg_class = Request diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/unreader.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/unreader.py new file mode 100644 index 0000000..273bfc3 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/unreader.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import io +import os + +# Classes that can undo reading data from +# a given type of data source. + + +class Unreader(object): + def __init__(self): + self.buf = io.BytesIO() + + def chunk(self): + raise NotImplementedError() + + def read(self, size=None): + if size is not None and not isinstance(size, int): + raise TypeError("size parameter must be an int or long.") + + if size is not None: + if size == 0: + return b"" + if size < 0: + size = None + + self.buf.seek(0, os.SEEK_END) + + if size is None and self.buf.tell(): + ret = self.buf.getvalue() + self.buf = io.BytesIO() + return ret + if size is None: + d = self.chunk() + return d + + while self.buf.tell() < size: + chunk = self.chunk() + if not chunk: + ret = self.buf.getvalue() + self.buf = io.BytesIO() + return ret + self.buf.write(chunk) + data = self.buf.getvalue() + self.buf = io.BytesIO() + self.buf.write(data[size:]) + return data[:size] + + def unread(self, data): + self.buf.seek(0, os.SEEK_END) + self.buf.write(data) + + +class SocketUnreader(Unreader): + def __init__(self, sock, max_chunk=8192): + super().__init__() + self.sock = sock + self.mxchunk = max_chunk + + def chunk(self): + return self.sock.recv(self.mxchunk) + + +class IterUnreader(Unreader): + def __init__(self, iterable): + super().__init__() + self.iter = iter(iterable) + + def chunk(self): + if not self.iter: + return b"" + try: + return next(self.iter) + except StopIteration: + self.iter = None + return b"" diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/wsgi.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/wsgi.py new file mode 100644 index 0000000..3524471 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/http/wsgi.py @@ -0,0 +1,405 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import io +import logging +import os +import re +import sys + +from gunicorn.http.message import HEADER_RE +from gunicorn.http.errors import InvalidHeader, InvalidHeaderName +from gunicorn import SERVER_SOFTWARE +import gunicorn.util as util + +# Send files in at most 1GB blocks as some operating systems can have problems +# with sending files in blocks over 2GB. +BLKSIZE = 0x3FFFFFFF + +HEADER_VALUE_RE = re.compile(r'[\x00-\x1F\x7F]') + +log = logging.getLogger(__name__) + + +class FileWrapper(object): + + def __init__(self, filelike, blksize=8192): + self.filelike = filelike + self.blksize = blksize + if hasattr(filelike, 'close'): + self.close = filelike.close + + def __getitem__(self, key): + data = self.filelike.read(self.blksize) + if data: + return data + raise IndexError + + +class WSGIErrorsWrapper(io.RawIOBase): + + def __init__(self, cfg): + # There is no public __init__ method for RawIOBase so + # we don't need to call super() in the __init__ method. + # pylint: disable=super-init-not-called + errorlog = logging.getLogger("gunicorn.error") + handlers = errorlog.handlers + self.streams = [] + + if cfg.errorlog == "-": + self.streams.append(sys.stderr) + handlers = handlers[1:] + + for h in handlers: + if hasattr(h, "stream"): + self.streams.append(h.stream) + + def write(self, data): + for stream in self.streams: + try: + stream.write(data) + except UnicodeError: + stream.write(data.encode("UTF-8")) + stream.flush() + + +def base_environ(cfg): + return { + "wsgi.errors": WSGIErrorsWrapper(cfg), + "wsgi.version": (1, 0), + "wsgi.multithread": False, + "wsgi.multiprocess": (cfg.workers > 1), + "wsgi.run_once": False, + "wsgi.file_wrapper": FileWrapper, + "wsgi.input_terminated": True, + "SERVER_SOFTWARE": SERVER_SOFTWARE, + } + + +def default_environ(req, sock, cfg): + env = base_environ(cfg) + env.update({ + "wsgi.input": req.body, + "gunicorn.socket": sock, + "REQUEST_METHOD": req.method, + "QUERY_STRING": req.query, + "RAW_URI": req.uri, + "SERVER_PROTOCOL": "HTTP/%s" % ".".join([str(v) for v in req.version]) + }) + return env + + +def proxy_environ(req): + info = req.proxy_protocol_info + + if not info: + return {} + + return { + "PROXY_PROTOCOL": info["proxy_protocol"], + "REMOTE_ADDR": info["client_addr"], + "REMOTE_PORT": str(info["client_port"]), + "PROXY_ADDR": info["proxy_addr"], + "PROXY_PORT": str(info["proxy_port"]), + } + + +def create(req, sock, client, server, cfg): + resp = Response(req, sock, cfg) + + # set initial environ + environ = default_environ(req, sock, cfg) + + # default variables + host = None + script_name = os.environ.get("SCRIPT_NAME", "") + + # add the headers to the environ + for hdr_name, hdr_value in req.headers: + if hdr_name == "EXPECT": + # handle expect + if hdr_value.lower() == "100-continue": + sock.send(b"HTTP/1.1 100 Continue\r\n\r\n") + elif hdr_name == 'HOST': + host = hdr_value + elif hdr_name == "SCRIPT_NAME": + script_name = hdr_value + elif hdr_name == "CONTENT-TYPE": + environ['CONTENT_TYPE'] = hdr_value + continue + elif hdr_name == "CONTENT-LENGTH": + environ['CONTENT_LENGTH'] = hdr_value + environ['wsgi.input_terminated'] = False + continue + + key = 'HTTP_' + hdr_name.replace('-', '_') + if key in environ: + hdr_value = "%s,%s" % (environ[key], hdr_value) + environ[key] = hdr_value + + # set the url scheme + environ['wsgi.url_scheme'] = req.scheme + + # set the REMOTE_* keys in environ + # authors should be aware that REMOTE_HOST and REMOTE_ADDR + # may not qualify the remote addr: + # http://www.ietf.org/rfc/rfc3875 + if isinstance(client, str): + environ['REMOTE_ADDR'] = client + elif isinstance(client, bytes): + environ['REMOTE_ADDR'] = client.decode() + else: + environ['REMOTE_ADDR'] = client[0] + environ['REMOTE_PORT'] = str(client[1]) + + # handle the SERVER_* + # Normally only the application should use the Host header but since the + # WSGI spec doesn't support unix sockets, we are using it to create + # viable SERVER_* if possible. + if isinstance(server, str): + server = server.split(":") + if len(server) == 1: + # unix socket + if host: + server = host.split(':') + if len(server) == 1: + if req.scheme == "http": + server.append(80) + elif req.scheme == "https": + server.append(443) + else: + server.append('') + else: + # no host header given which means that we are not behind a + # proxy, so append an empty port. + server.append('') + environ['SERVER_NAME'] = server[0] + environ['SERVER_PORT'] = str(server[1]) + + # set the path and script name + path_info = req.path + if script_name: + path_info = path_info.split(script_name, 1)[1] + environ['PATH_INFO'] = util.unquote_to_wsgi_str(path_info) + environ['SCRIPT_NAME'] = script_name + + # override the environ with the correct remote and server address if + # we are behind a proxy using the proxy protocol. + environ.update(proxy_environ(req)) + return resp, environ + + +class Response(object): + + def __init__(self, req, sock, cfg): + self.req = req + self.sock = sock + self.version = SERVER_SOFTWARE + self.status = None + self.chunked = False + self.must_close = False + self.headers = [] + self.headers_sent = False + self.response_length = None + self.sent = 0 + self.upgrade = False + self.cfg = cfg + + def force_close(self): + self.must_close = True + + def should_close(self): + if self.must_close or self.req.should_close(): + return True + if self.response_length is not None or self.chunked: + return False + if self.req.method == 'HEAD': + return False + if self.status_code < 200 or self.status_code in (204, 304): + return False + return True + + def start_response(self, status, headers, exc_info=None): + if exc_info: + try: + if self.status and self.headers_sent: + util.reraise(exc_info[0], exc_info[1], exc_info[2]) + finally: + exc_info = None + elif self.status is not None: + raise AssertionError("Response headers already set!") + + self.status = status + + # get the status code from the response here so we can use it to check + # the need for the connection header later without parsing the string + # each time. + try: + self.status_code = int(self.status.split()[0]) + except ValueError: + self.status_code = None + + self.process_headers(headers) + self.chunked = self.is_chunked() + return self.write + + def process_headers(self, headers): + for name, value in headers: + if not isinstance(name, str): + raise TypeError('%r is not a string' % name) + + if HEADER_RE.search(name): + raise InvalidHeaderName('%r' % name) + + if not isinstance(value, str): + raise TypeError('%r is not a string' % value) + + if HEADER_VALUE_RE.search(value): + raise InvalidHeader('%r' % value) + + value = value.strip() + lname = name.lower().strip() + if lname == "content-length": + self.response_length = int(value) + elif util.is_hoppish(name): + if lname == "connection": + # handle websocket + if value.lower().strip() == "upgrade": + self.upgrade = True + elif lname == "upgrade": + if value.lower().strip() == "websocket": + self.headers.append((name.strip(), value)) + + # ignore hopbyhop headers + continue + self.headers.append((name.strip(), value)) + + def is_chunked(self): + # Only use chunked responses when the client is + # speaking HTTP/1.1 or newer and there was + # no Content-Length header set. + if self.response_length is not None: + return False + elif self.req.version <= (1, 0): + return False + elif self.req.method == 'HEAD': + # Responses to a HEAD request MUST NOT contain a response body. + return False + elif self.status_code in (204, 304): + # Do not use chunked responses when the response is guaranteed to + # not have a response body. + return False + return True + + def default_headers(self): + # set the connection header + if self.upgrade: + connection = "upgrade" + elif self.should_close(): + connection = "close" + else: + connection = "keep-alive" + + headers = [ + "HTTP/%s.%s %s\r\n" % (self.req.version[0], + self.req.version[1], self.status), + "Server: %s\r\n" % self.version, + "Date: %s\r\n" % util.http_date(), + "Connection: %s\r\n" % connection + ] + if self.chunked: + headers.append("Transfer-Encoding: chunked\r\n") + return headers + + def send_headers(self): + if self.headers_sent: + return + tosend = self.default_headers() + tosend.extend(["%s: %s\r\n" % (k, v) for k, v in self.headers]) + + header_str = "%s\r\n" % "".join(tosend) + util.write(self.sock, util.to_bytestring(header_str, "latin-1")) + self.headers_sent = True + + def write(self, arg): + self.send_headers() + if not isinstance(arg, bytes): + raise TypeError('%r is not a byte' % arg) + arglen = len(arg) + tosend = arglen + if self.response_length is not None: + if self.sent >= self.response_length: + # Never write more than self.response_length bytes + return + + tosend = min(self.response_length - self.sent, tosend) + if tosend < arglen: + arg = arg[:tosend] + + # Sending an empty chunk signals the end of the + # response and prematurely closes the response + if self.chunked and tosend == 0: + return + + self.sent += tosend + util.write(self.sock, arg, self.chunked) + + def can_sendfile(self): + return self.cfg.sendfile is not False + + def sendfile(self, respiter): + if self.cfg.is_ssl or not self.can_sendfile(): + return False + + if not util.has_fileno(respiter.filelike): + return False + + fileno = respiter.filelike.fileno() + try: + offset = os.lseek(fileno, 0, os.SEEK_CUR) + if self.response_length is None: + filesize = os.fstat(fileno).st_size + + # The file may be special and sendfile will fail. + # It may also be zero-length, but that is okay. + if filesize == 0: + return False + + nbytes = filesize - offset + else: + nbytes = self.response_length + except (OSError, io.UnsupportedOperation): + return False + + self.send_headers() + + if self.is_chunked(): + chunk_size = "%X\r\n" % nbytes + self.sock.sendall(chunk_size.encode('utf-8')) + + sockno = self.sock.fileno() + sent = 0 + + while sent != nbytes: + count = min(nbytes - sent, BLKSIZE) + sent += os.sendfile(sockno, fileno, offset + sent, count) + + if self.is_chunked(): + self.sock.sendall(b"\r\n") + + os.lseek(fileno, offset, os.SEEK_SET) + + return True + + def write_file(self, respiter): + if not self.sendfile(respiter): + for item in respiter: + self.write(item) + + def close(self): + if not self.headers_sent: + self.send_headers() + if self.chunked: + util.write_chunk(self.sock, b"") diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__init__.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__pycache__/__init__.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fc720be9b0d2bba0dfc9c7e729e65403f1f0f69 GIT binary patch literal 153 zcmZ?b<>g`kf-^=JV?p#|5CH>>K!yVl7qb9~6oz01O-8?!3`HPe1o6vBza+OnzaXDoNRhIw$S>t#_;nJ-68&fvt(zv2E!p*nP50Pxny^lAU<^ouCINb8 z=-M>2k{8*uKcPp;>8Agri=Lj-Ew){>*>&AjzdHaaQT4*d1~qpE7lXk!ckbN#jjq+} zRSnnQuKeS>6APO5Pr8|0786)nbj{1?6!?| zsawOzZZu{l*bmO5#ws(O}pQ z2VpFI86~lsbXHS(PY~u zGnn~GYg^1>CDbKmvodO%Ijn-Z%&Ke-wZm$xj=I9;*&)OFJY zOf}DX@fq5shsKt%WlDR;mUgd<;_MoDT1mBDWv7}NaxOKu^^UQt>)LO%c*)Xa?MapQ zbd7$DMyh&isT8}hIdJT!G@rj{{3P)FclDwi3@;9&;R-F6-|w#sf=le_Xn6TzcN9lK z!sETh-ilt#ztJ4N;By#;h7#DKnr7DY!@8kY^#%QeKCjn|@uB<5IhqqY%&au6_Fa1U z9E8+*YNb0yYW&Ga%|BwjQf)`AIjug^uqtM2d~|}W2?uHhJd#o1_kYqcM8hnsKG9~C zC=R&VwGE3OMVHJR2$;g>U6I*OeowVBMJ|@mgMR?=35pOn&R{N2 zly8pu3=m(MK|NofF2;Iy+{b2chm)-`gS@h*esk<+f%~%=?1v{7pL}EnJ;ej%?Brw! zPMXwv2xj};UAeg4YM7Y`-_FVuAz|gry4AXI_l^7@v!b|@{DNSqkgAX83Q(kfYdoAb zC_fL8mDV?|J-GR1U`i}}H0u6pADW3%ss{m?gsut-MSW$SzoYTu&#ASelKQT(RZ2_D zcv9g%q@^7gjTz9{s%@xtS+$V?p?6Xn{mLi~6=^*&_(MdIQfjAViX!ncv^KOH+VWI; z3|a@;AE2#FwOVTMA7!;SM;RzJI%aAjGFcRvkV(!JndGl|CP6=B4`xyZ{)4G&c}`J8 z!XB^RPP(q|cB5xuta1smdla})$IaQmva8sD>&MI`KH!3PfL4S8Y+{;ivQqe5a=$e` ze#4LY$gwh^BubS~QFaqF!+|d&=X8?Bd}el$N2+%=Ht*fK?tQ&>FROgLcKg9b-n_H< z?QimC_2$}xn;Rb8^D?ZT)vn)t(AwO%m#b(?Wb?nib$|0N<)BNIdzJ$ARweW73 zA)rC&qA5_hjv~eo6AqCgtEAR$3303#I1G>W}Vcwb$Fh(Q)Tc;@+P$Bz_jqRXv3q9!3R{nA`0n@TX#ZVjIf$Kd^!q+ zblHe2202~U;(;flLFh)rjF>M&x@(ePVPE>w&e6ZIX<90JaY}jPlhgQCjMJQaV0`4@ zBQah&sA`huj70N1Yt-`OY5PGC3XzpX2%5n}R_gQdQy>N+q8q*j9v+a3B9)c;t5WA!>oEp0(F+>%Djn=sK^3vAJ z%Uf4pUfD{!2*_2Bn3sqB$TGW=@PRLR4MQSfD_UX2{vcF-eGo0VVuUgY$deGL2>-wE z0M~!M3>4Wwljwb%6Rl zvkt`nn>1f{J~in9c)9Pt2H4)YP9YS0OXM4=BLW>ubz;D~`WE@A$uFhI zf5(YFn7JNNi=J5g8cF0i^qpoW8|R$IMRqFpoY!P0;?#C4EBPXbBDLJ<+3~3j;-fh0 z#0(yS3?+o$4QJ8}zW|(w^~5yzRfx`B6frV?@=o^+m(Rp#rh~NU^c^b|OyK{2JbvR10+8qK)Wz*s$IpVWU2^Yo7OX z5rr>R9Lho2?!F^L8V%14~yjY^E1HU?iOp+cM5WqY$wEeb81 z{&R5*MG$Fs3`=(oIhOjBAWdfp_huD8$5efBT>OgOJ5Qnxkr_P9kBoakyj#%0JngPf t*CvUJB#1@x%OtLlAOQP3a*8Z-KF_W4g^eD9Fj|H~Io7C|mOlL%{{!_Q`GWue literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/statsd.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/statsd.py new file mode 100644 index 0000000..9a53720 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/instrument/statsd.py @@ -0,0 +1,129 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +"Bare-bones implementation of statsD's protocol, client-side" + +import logging +import socket +from re import sub + +from gunicorn.glogging import Logger + +# Instrumentation constants +METRIC_VAR = "metric" +VALUE_VAR = "value" +MTYPE_VAR = "mtype" +GAUGE_TYPE = "gauge" +COUNTER_TYPE = "counter" +HISTOGRAM_TYPE = "histogram" + +class Statsd(Logger): + """statsD-based instrumentation, that passes as a logger + """ + def __init__(self, cfg): + """host, port: statsD server + """ + Logger.__init__(self, cfg) + self.prefix = sub(r"^(.+[^.]+)\.*$", "\\g<1>.", cfg.statsd_prefix) + try: + host, port = cfg.statsd_host + self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + self.sock.connect((host, int(port))) + except Exception: + self.sock = None + + self.dogstatsd_tags = cfg.dogstatsd_tags + + # Log errors and warnings + def critical(self, msg, *args, **kwargs): + Logger.critical(self, msg, *args, **kwargs) + self.increment("gunicorn.log.critical", 1) + + def error(self, msg, *args, **kwargs): + Logger.error(self, msg, *args, **kwargs) + self.increment("gunicorn.log.error", 1) + + def warning(self, msg, *args, **kwargs): + Logger.warning(self, msg, *args, **kwargs) + self.increment("gunicorn.log.warning", 1) + + def exception(self, msg, *args, **kwargs): + Logger.exception(self, msg, *args, **kwargs) + self.increment("gunicorn.log.exception", 1) + + # Special treatment for info, the most common log level + def info(self, msg, *args, **kwargs): + self.log(logging.INFO, msg, *args, **kwargs) + + # skip the run-of-the-mill logs + def debug(self, msg, *args, **kwargs): + self.log(logging.DEBUG, msg, *args, **kwargs) + + def log(self, lvl, msg, *args, **kwargs): + """Log a given statistic if metric, value and type are present + """ + try: + extra = kwargs.get("extra", None) + if extra is not None: + metric = extra.get(METRIC_VAR, None) + value = extra.get(VALUE_VAR, None) + typ = extra.get(MTYPE_VAR, None) + if metric and value and typ: + if typ == GAUGE_TYPE: + self.gauge(metric, value) + elif typ == COUNTER_TYPE: + self.increment(metric, value) + elif typ == HISTOGRAM_TYPE: + self.histogram(metric, value) + else: + pass + + # Log to parent logger only if there is something to say + if msg: + Logger.log(self, lvl, msg, *args, **kwargs) + except Exception: + Logger.warning(self, "Failed to log to statsd", exc_info=True) + + # access logging + def access(self, resp, req, environ, request_time): + """Measure request duration + request_time is a datetime.timedelta + """ + Logger.access(self, resp, req, environ, request_time) + duration_in_ms = request_time.seconds * 1000 + float(request_time.microseconds) / 10 ** 3 + status = resp.status + if isinstance(status, str): + status = int(status.split(None, 1)[0]) + self.histogram("gunicorn.request.duration", duration_in_ms) + self.increment("gunicorn.requests", 1) + self.increment("gunicorn.request.status.%d" % status, 1) + + # statsD methods + # you can use those directly if you want + def gauge(self, name, value): + self._sock_send("{0}{1}:{2}|g".format(self.prefix, name, value)) + + def increment(self, name, value, sampling_rate=1.0): + self._sock_send("{0}{1}:{2}|c|@{3}".format(self.prefix, name, value, sampling_rate)) + + def decrement(self, name, value, sampling_rate=1.0): + self._sock_send("{0}{1}:-{2}|c|@{3}".format(self.prefix, name, value, sampling_rate)) + + def histogram(self, name, value): + self._sock_send("{0}{1}:{2}|ms".format(self.prefix, name, value)) + + def _sock_send(self, msg): + try: + if isinstance(msg, str): + msg = msg.encode("ascii") + + # http://docs.datadoghq.com/guides/dogstatsd/#datagram-format + if self.dogstatsd_tags: + msg = msg + b"|#" + self.dogstatsd_tags.encode('ascii') + + if self.sock: + self.sock.send(msg) + except Exception: + Logger.warning(self, "Error sending message to statsd", exc_info=True) diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/pidfile.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/pidfile.py new file mode 100644 index 0000000..a6e085f --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/pidfile.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import errno +import os +import tempfile + + +class Pidfile(object): + """\ + Manage a PID file. If a specific name is provided + it and '"%s.oldpid" % name' will be used. Otherwise + we create a temp file using os.mkstemp. + """ + + def __init__(self, fname): + self.fname = fname + self.pid = None + + def create(self, pid): + oldpid = self.validate() + if oldpid: + if oldpid == os.getpid(): + return + msg = "Already running on PID %s (or pid file '%s' is stale)" + raise RuntimeError(msg % (oldpid, self.fname)) + + self.pid = pid + + # Write pidfile + fdir = os.path.dirname(self.fname) + if fdir and not os.path.isdir(fdir): + raise RuntimeError("%s doesn't exist. Can't create pidfile." % fdir) + fd, fname = tempfile.mkstemp(dir=fdir) + os.write(fd, ("%s\n" % self.pid).encode('utf-8')) + if self.fname: + os.rename(fname, self.fname) + else: + self.fname = fname + os.close(fd) + + # set permissions to -rw-r--r-- + os.chmod(self.fname, 420) + + def rename(self, path): + self.unlink() + self.fname = path + self.create(self.pid) + + def unlink(self): + """ delete pidfile""" + try: + with open(self.fname, "r") as f: + pid1 = int(f.read() or 0) + + if pid1 == self.pid: + os.unlink(self.fname) + except: + pass + + def validate(self): + """ Validate pidfile and make it stale if needed""" + if not self.fname: + return + try: + with open(self.fname, "r") as f: + try: + wpid = int(f.read()) + except ValueError: + return + + try: + os.kill(wpid, 0) + return wpid + except OSError as e: + if e.args[0] == errno.EPERM: + return wpid + if e.args[0] == errno.ESRCH: + return + raise + except IOError as e: + if e.args[0] == errno.ENOENT: + return + raise diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/reloader.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/reloader.py new file mode 100644 index 0000000..acfc2f8 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/reloader.py @@ -0,0 +1,133 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. +# pylint: disable=no-else-continue + +import os +import os.path +import re +import sys +import time +import threading + +COMPILED_EXT_RE = re.compile(r'py[co]$') + + +class Reloader(threading.Thread): + def __init__(self, extra_files=None, interval=1, callback=None): + super().__init__() + self.setDaemon(True) + self._extra_files = set(extra_files or ()) + self._extra_files_lock = threading.RLock() + self._interval = interval + self._callback = callback + + def add_extra_file(self, filename): + with self._extra_files_lock: + self._extra_files.add(filename) + + def get_files(self): + fnames = [ + COMPILED_EXT_RE.sub('py', module.__file__) + for module in tuple(sys.modules.values()) + if getattr(module, '__file__', None) + ] + + with self._extra_files_lock: + fnames.extend(self._extra_files) + + return fnames + + def run(self): + mtimes = {} + while True: + for filename in self.get_files(): + try: + mtime = os.stat(filename).st_mtime + except OSError: + continue + old_time = mtimes.get(filename) + if old_time is None: + mtimes[filename] = mtime + continue + elif mtime > old_time: + if self._callback: + self._callback(filename) + time.sleep(self._interval) + +has_inotify = False +if sys.platform.startswith('linux'): + try: + from inotify.adapters import Inotify + import inotify.constants + has_inotify = True + except ImportError: + pass + + +if has_inotify: + + class InotifyReloader(threading.Thread): + event_mask = (inotify.constants.IN_CREATE | inotify.constants.IN_DELETE + | inotify.constants.IN_DELETE_SELF | inotify.constants.IN_MODIFY + | inotify.constants.IN_MOVE_SELF | inotify.constants.IN_MOVED_FROM + | inotify.constants.IN_MOVED_TO) + + def __init__(self, extra_files=None, callback=None): + super().__init__() + self.setDaemon(True) + self._callback = callback + self._dirs = set() + self._watcher = Inotify() + + for extra_file in extra_files: + self.add_extra_file(extra_file) + + def add_extra_file(self, filename): + dirname = os.path.dirname(filename) + + if dirname in self._dirs: + return + + self._watcher.add_watch(dirname, mask=self.event_mask) + self._dirs.add(dirname) + + def get_dirs(self): + fnames = [ + os.path.dirname(COMPILED_EXT_RE.sub('py', module.__file__)) + for module in tuple(sys.modules.values()) + if getattr(module, '__file__', None) + ] + + return set(fnames) + + def run(self): + self._dirs = self.get_dirs() + + for dirname in self._dirs: + self._watcher.add_watch(dirname, mask=self.event_mask) + + for event in self._watcher.event_gen(): + if event is None: + continue + + filename = event[3] + + self._callback(filename) + +else: + + class InotifyReloader(object): + def __init__(self, callback=None): + raise ImportError('You must have the inotify module installed to ' + 'use the inotify reloader') + + +preferred_reloader = InotifyReloader if has_inotify else Reloader + +reloader_engines = { + 'auto': preferred_reloader, + 'poll': Reloader, + 'inotify': InotifyReloader, +} diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/sock.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/sock.py new file mode 100644 index 0000000..e53e578 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/sock.py @@ -0,0 +1,213 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import errno +import os +import socket +import stat +import sys +import time + +from gunicorn import util +from gunicorn.socketfromfd import fromfd + + +class BaseSocket(object): + + def __init__(self, address, conf, log, fd=None): + self.log = log + self.conf = conf + + self.cfg_addr = address + if fd is None: + sock = socket.socket(self.FAMILY, socket.SOCK_STREAM) + bound = False + else: + sock = socket.fromfd(fd, self.FAMILY, socket.SOCK_STREAM) + os.close(fd) + bound = True + + self.sock = self.set_options(sock, bound=bound) + + def __str__(self): + return "" % self.sock.fileno() + + def __getattr__(self, name): + return getattr(self.sock, name) + + def set_options(self, sock, bound=False): + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + if (self.conf.reuse_port + and hasattr(socket, 'SO_REUSEPORT')): # pragma: no cover + try: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) + except socket.error as err: + if err.errno not in (errno.ENOPROTOOPT, errno.EINVAL): + raise + if not bound: + self.bind(sock) + sock.setblocking(0) + + # make sure that the socket can be inherited + if hasattr(sock, "set_inheritable"): + sock.set_inheritable(True) + + sock.listen(self.conf.backlog) + return sock + + def bind(self, sock): + sock.bind(self.cfg_addr) + + def close(self): + if self.sock is None: + return + + try: + self.sock.close() + except socket.error as e: + self.log.info("Error while closing socket %s", str(e)) + + self.sock = None + + +class TCPSocket(BaseSocket): + + FAMILY = socket.AF_INET + + def __str__(self): + if self.conf.is_ssl: + scheme = "https" + else: + scheme = "http" + + addr = self.sock.getsockname() + return "%s://%s:%d" % (scheme, addr[0], addr[1]) + + def set_options(self, sock, bound=False): + sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + return super().set_options(sock, bound=bound) + + +class TCP6Socket(TCPSocket): + + FAMILY = socket.AF_INET6 + + def __str__(self): + (host, port, _, _) = self.sock.getsockname() + return "http://[%s]:%d" % (host, port) + + +class UnixSocket(BaseSocket): + + FAMILY = socket.AF_UNIX + + def __init__(self, addr, conf, log, fd=None): + if fd is None: + try: + st = os.stat(addr) + except OSError as e: + if e.args[0] != errno.ENOENT: + raise + else: + if stat.S_ISSOCK(st.st_mode): + os.remove(addr) + else: + raise ValueError("%r is not a socket" % addr) + super().__init__(addr, conf, log, fd=fd) + + def __str__(self): + return "unix:%s" % self.cfg_addr + + def bind(self, sock): + old_umask = os.umask(self.conf.umask) + sock.bind(self.cfg_addr) + util.chown(self.cfg_addr, self.conf.uid, self.conf.gid) + os.umask(old_umask) + + +def _sock_type(addr): + if isinstance(addr, tuple): + if util.is_ipv6(addr[0]): + sock_type = TCP6Socket + else: + sock_type = TCPSocket + elif isinstance(addr, (str, bytes)): + sock_type = UnixSocket + else: + raise TypeError("Unable to create socket from: %r" % addr) + return sock_type + + +def create_sockets(conf, log, fds=None): + """ + Create a new socket for the configured addresses or file descriptors. + + If a configured address is a tuple then a TCP socket is created. + If it is a string, a Unix socket is created. Otherwise, a TypeError is + raised. + """ + listeners = [] + + # get it only once + addr = conf.address + fdaddr = [bind for bind in addr if isinstance(bind, int)] + if fds: + fdaddr += list(fds) + laddr = [bind for bind in addr if not isinstance(bind, int)] + + # check ssl config early to raise the error on startup + # only the certfile is needed since it can contains the keyfile + if conf.certfile and not os.path.exists(conf.certfile): + raise ValueError('certfile "%s" does not exist' % conf.certfile) + + if conf.keyfile and not os.path.exists(conf.keyfile): + raise ValueError('keyfile "%s" does not exist' % conf.keyfile) + + # sockets are already bound + if fdaddr: + for fd in fdaddr: + sock = fromfd(fd) + sock_name = sock.getsockname() + sock_type = _sock_type(sock_name) + listener = sock_type(sock_name, conf, log, fd=fd) + listeners.append(listener) + + return listeners + + # no sockets is bound, first initialization of gunicorn in this env. + for addr in laddr: + sock_type = _sock_type(addr) + sock = None + for i in range(5): + try: + sock = sock_type(addr, conf, log) + except socket.error as e: + if e.args[0] == errno.EADDRINUSE: + log.error("Connection in use: %s", str(addr)) + if e.args[0] == errno.EADDRNOTAVAIL: + log.error("Invalid address: %s", str(addr)) + if i < 5: + msg = "connection to {addr} failed: {error}" + log.debug(msg.format(addr=str(addr), error=str(e))) + log.error("Retrying in 1 second.") + time.sleep(1) + else: + break + + if sock is None: + log.error("Can't connect to %s", str(addr)) + sys.exit(1) + + listeners.append(sock) + + return listeners + + +def close_sockets(listeners, unlink=True): + for sock in listeners: + sock_name = sock.getsockname() + sock.close() + if unlink and _sock_type(sock_name) is UnixSocket: + os.unlink(sock_name) diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/socketfromfd.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/socketfromfd.py new file mode 100644 index 0000000..4c2847b --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/socketfromfd.py @@ -0,0 +1,96 @@ +# Copyright (C) 2016 Christian Heimes +"""socketfromfd -- socket.fromd() with auto-discovery + +ATTENTION: Do not remove this backport till the minimum required version is + Python 3.7. See https://bugs.python.org/issue28134 for details. +""" +from __future__ import print_function + +import ctypes +import os +import socket +import sys +from ctypes.util import find_library + +__all__ = ('fromfd',) + +SO_DOMAIN = getattr(socket, 'SO_DOMAIN', 39) +SO_TYPE = getattr(socket, 'SO_TYPE', 3) +SO_PROTOCOL = getattr(socket, 'SO_PROTOCOL', 38) + + +_libc_name = find_library('c') +if _libc_name is not None: + libc = ctypes.CDLL(_libc_name, use_errno=True) +else: + raise OSError('libc not found') + + +def _errcheck_errno(result, func, arguments): + """Raise OSError by errno for -1 + """ + if result == -1: + errno = ctypes.get_errno() + raise OSError(errno, os.strerror(errno)) + return arguments + + +_libc_getsockopt = libc.getsockopt +_libc_getsockopt.argtypes = [ + ctypes.c_int, # int sockfd + ctypes.c_int, # int level + ctypes.c_int, # int optname + ctypes.c_void_p, # void *optval + ctypes.POINTER(ctypes.c_uint32) # socklen_t *optlen +] +_libc_getsockopt.restype = ctypes.c_int # 0: ok, -1: err +_libc_getsockopt.errcheck = _errcheck_errno + + +def _raw_getsockopt(fd, level, optname): + """Make raw getsockopt() call for int32 optval + + :param fd: socket fd + :param level: SOL_* + :param optname: SO_* + :return: value as int + """ + optval = ctypes.c_int(0) + optlen = ctypes.c_uint32(4) + _libc_getsockopt(fd, level, optname, + ctypes.byref(optval), ctypes.byref(optlen)) + return optval.value + + +def fromfd(fd, keep_fd=True): + """Create a socket from a file descriptor + + socket domain (family), type and protocol are auto-detected. By default + the socket uses a dup()ed fd. The original fd can be closed. + + The parameter `keep_fd` influences fd duplication. Under Python 2 the + fd is still duplicated but the input fd is closed. Under Python 3 and + with `keep_fd=True`, the new socket object uses the same fd. + + :param fd: socket fd + :type fd: int + :param keep_fd: keep input fd + :type keep_fd: bool + :return: socket.socket instance + :raises OSError: for invalid socket fd + """ + family = _raw_getsockopt(fd, socket.SOL_SOCKET, SO_DOMAIN) + typ = _raw_getsockopt(fd, socket.SOL_SOCKET, SO_TYPE) + proto = _raw_getsockopt(fd, socket.SOL_SOCKET, SO_PROTOCOL) + if sys.version_info.major == 2: + # Python 2 has no fileno argument and always duplicates the fd + sockobj = socket.fromfd(fd, family, typ, proto) + sock = socket.socket(None, None, None, _sock=sockobj) + if not keep_fd: + os.close(fd) + return sock + else: + if keep_fd: + return socket.fromfd(fd, family, typ, proto) + else: + return socket.socket(family, typ, proto, fileno=fd) diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/systemd.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/systemd.py new file mode 100644 index 0000000..cea4822 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/systemd.py @@ -0,0 +1,77 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import os +import socket + +SD_LISTEN_FDS_START = 3 + + +def listen_fds(unset_environment=True): + """ + Get the number of sockets inherited from systemd socket activation. + + :param unset_environment: clear systemd environment variables unless False + :type unset_environment: bool + :return: the number of sockets to inherit from systemd socket activation + :rtype: int + + Returns zero immediately if $LISTEN_PID is not set to the current pid. + Otherwise, returns the number of systemd activation sockets specified by + $LISTEN_FDS. + + When $LISTEN_PID matches the current pid, unsets the environment variables + unless the ``unset_environment`` flag is ``False``. + + .. note:: + Unlike the sd_listen_fds C function, this implementation does not set + the FD_CLOEXEC flag because the gunicorn arbiter never needs to do this. + + .. seealso:: + ``_ + + """ + fds = int(os.environ.get('LISTEN_FDS', 0)) + listen_pid = int(os.environ.get('LISTEN_PID', 0)) + + if listen_pid != os.getpid(): + return 0 + + if unset_environment: + os.environ.pop('LISTEN_PID', None) + os.environ.pop('LISTEN_FDS', None) + + return fds + + +def sd_notify(state, logger, unset_environment=False): + """Send a notification to systemd. state is a string; see + the man page of sd_notify (http://www.freedesktop.org/software/systemd/man/sd_notify.html) + for a description of the allowable values. + + If the unset_environment parameter is True, sd_notify() will unset + the $NOTIFY_SOCKET environment variable before returning (regardless of + whether the function call itself succeeded or not). Further calls to + sd_notify() will then fail, but the variable is no longer inherited by + child processes. + """ + + + addr = os.environ.get('NOTIFY_SOCKET') + if addr is None: + # not run in a service, just a noop + return + try: + sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM | socket.SOCK_CLOEXEC) + if addr[0] == '@': + addr = '\0' + addr[1:] + sock.connect(addr) + sock.sendall(state.encode('utf-8')) + except: + logger.debug("Exception while invoking sd_notify()", exc_info=True) + finally: + if unset_environment: + os.environ.pop('NOTIFY_SOCKET') + sock.close() diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/util.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/util.py new file mode 100644 index 0000000..fbdd5cf --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/util.py @@ -0,0 +1,559 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import email.utils +import errno +import fcntl +import html +import importlib +import inspect +import io +import logging +import os +import pwd +import random +import re +import socket +import sys +import textwrap +import time +import traceback +import warnings + +import pkg_resources + +from gunicorn.errors import AppImportError +from gunicorn.workers import SUPPORTED_WORKERS +import urllib.parse + +REDIRECT_TO = getattr(os, 'devnull', '/dev/null') + +# Server and Date aren't technically hop-by-hop +# headers, but they are in the purview of the +# origin server which the WSGI spec says we should +# act like. So we drop them and add our own. +# +# In the future, concatenation server header values +# might be better, but nothing else does it and +# dropping them is easier. +hop_headers = set(""" + connection keep-alive proxy-authenticate proxy-authorization + te trailers transfer-encoding upgrade + server date + """.split()) + +try: + from setproctitle import setproctitle + + def _setproctitle(title): + setproctitle("gunicorn: %s" % title) +except ImportError: + def _setproctitle(title): + pass + + +def load_class(uri, default="gunicorn.workers.sync.SyncWorker", + section="gunicorn.workers"): + if inspect.isclass(uri): + return uri + if uri.startswith("egg:"): + # uses entry points + entry_str = uri.split("egg:")[1] + try: + dist, name = entry_str.rsplit("#", 1) + except ValueError: + dist = entry_str + name = default + + try: + return pkg_resources.load_entry_point(dist, section, name) + except: + exc = traceback.format_exc() + msg = "class uri %r invalid or not found: \n\n[%s]" + raise RuntimeError(msg % (uri, exc)) + else: + components = uri.split('.') + if len(components) == 1: + while True: + if uri.startswith("#"): + uri = uri[1:] + + if uri in SUPPORTED_WORKERS: + components = SUPPORTED_WORKERS[uri].split(".") + break + + try: + return pkg_resources.load_entry_point("gunicorn", + section, uri) + except: + exc = traceback.format_exc() + msg = "class uri %r invalid or not found: \n\n[%s]" + raise RuntimeError(msg % (uri, exc)) + + klass = components.pop(-1) + + try: + mod = importlib.import_module('.'.join(components)) + except: + exc = traceback.format_exc() + msg = "class uri %r invalid or not found: \n\n[%s]" + raise RuntimeError(msg % (uri, exc)) + return getattr(mod, klass) + + +positionals = ( + inspect.Parameter.POSITIONAL_ONLY, + inspect.Parameter.POSITIONAL_OR_KEYWORD, +) + + +def get_arity(f): + sig = inspect.signature(f) + arity = 0 + + for param in sig.parameters.values(): + if param.kind in positionals: + arity += 1 + + return arity + + +def get_username(uid): + """ get the username for a user id""" + return pwd.getpwuid(uid).pw_name + + +def set_owner_process(uid, gid, initgroups=False): + """ set user and group of workers processes """ + + if gid: + if uid: + try: + username = get_username(uid) + except KeyError: + initgroups = False + + # versions of python < 2.6.2 don't manage unsigned int for + # groups like on osx or fedora + gid = abs(gid) & 0x7FFFFFFF + + if initgroups: + os.initgroups(username, gid) + elif gid != os.getgid(): + os.setgid(gid) + + if uid: + os.setuid(uid) + + +def chown(path, uid, gid): + os.chown(path, uid, gid) + + +if sys.platform.startswith("win"): + def _waitfor(func, pathname, waitall=False): + # Perform the operation + func(pathname) + # Now setup the wait loop + if waitall: + dirname = pathname + else: + dirname, name = os.path.split(pathname) + dirname = dirname or '.' + # Check for `pathname` to be removed from the filesystem. + # The exponential backoff of the timeout amounts to a total + # of ~1 second after which the deletion is probably an error + # anyway. + # Testing on a i7@4.3GHz shows that usually only 1 iteration is + # required when contention occurs. + timeout = 0.001 + while timeout < 1.0: + # Note we are only testing for the existence of the file(s) in + # the contents of the directory regardless of any security or + # access rights. If we have made it this far, we have sufficient + # permissions to do that much using Python's equivalent of the + # Windows API FindFirstFile. + # Other Windows APIs can fail or give incorrect results when + # dealing with files that are pending deletion. + L = os.listdir(dirname) + if not L if waitall else name in L: + return + # Increase the timeout and try again + time.sleep(timeout) + timeout *= 2 + warnings.warn('tests may fail, delete still pending for ' + pathname, + RuntimeWarning, stacklevel=4) + + def _unlink(filename): + _waitfor(os.unlink, filename) +else: + _unlink = os.unlink + + +def unlink(filename): + try: + _unlink(filename) + except OSError as error: + # The filename need not exist. + if error.errno not in (errno.ENOENT, errno.ENOTDIR): + raise + + +def is_ipv6(addr): + try: + socket.inet_pton(socket.AF_INET6, addr) + except socket.error: # not a valid address + return False + except ValueError: # ipv6 not supported on this platform + return False + return True + + +def parse_address(netloc, default_port='8000'): + if re.match(r'unix:(//)?', netloc): + return re.split(r'unix:(//)?', netloc)[-1] + + if netloc.startswith("fd://"): + fd = netloc[5:] + try: + return int(fd) + except ValueError: + raise RuntimeError("%r is not a valid file descriptor." % fd) from None + + if netloc.startswith("tcp://"): + netloc = netloc.split("tcp://")[1] + host, port = netloc, default_port + + if '[' in netloc and ']' in netloc: + host = netloc.split(']')[0][1:] + port = (netloc.split(']:') + [default_port])[1] + elif ':' in netloc: + host, port = (netloc.split(':') + [default_port])[:2] + elif netloc == "": + host, port = "0.0.0.0", default_port + + try: + port = int(port) + except ValueError: + raise RuntimeError("%r is not a valid port number." % port) + + return host.lower(), port + + +def close_on_exec(fd): + flags = fcntl.fcntl(fd, fcntl.F_GETFD) + flags |= fcntl.FD_CLOEXEC + fcntl.fcntl(fd, fcntl.F_SETFD, flags) + + +def set_non_blocking(fd): + flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK + fcntl.fcntl(fd, fcntl.F_SETFL, flags) + + +def close(sock): + try: + sock.close() + except socket.error: + pass + +try: + from os import closerange +except ImportError: + def closerange(fd_low, fd_high): + # Iterate through and close all file descriptors. + for fd in range(fd_low, fd_high): + try: + os.close(fd) + except OSError: # ERROR, fd wasn't open to begin with (ignored) + pass + + +def write_chunk(sock, data): + if isinstance(data, str): + data = data.encode('utf-8') + chunk_size = "%X\r\n" % len(data) + chunk = b"".join([chunk_size.encode('utf-8'), data, b"\r\n"]) + sock.sendall(chunk) + + +def write(sock, data, chunked=False): + if chunked: + return write_chunk(sock, data) + sock.sendall(data) + + +def write_nonblock(sock, data, chunked=False): + timeout = sock.gettimeout() + if timeout != 0.0: + try: + sock.setblocking(0) + return write(sock, data, chunked) + finally: + sock.setblocking(1) + else: + return write(sock, data, chunked) + + +def write_error(sock, status_int, reason, mesg): + html_error = textwrap.dedent("""\ + + + %(reason)s + + +

%(reason)s

+ %(mesg)s + + + """) % {"reason": reason, "mesg": html.escape(mesg)} + + http = textwrap.dedent("""\ + HTTP/1.1 %s %s\r + Connection: close\r + Content-Type: text/html\r + Content-Length: %d\r + \r + %s""") % (str(status_int), reason, len(html_error), html_error) + write_nonblock(sock, http.encode('latin1')) + + +def import_app(module): + parts = module.split(":", 1) + if len(parts) == 1: + obj = "application" + else: + module, obj = parts[0], parts[1] + + try: + mod = importlib.import_module(module) + except ImportError: + if module.endswith(".py") and os.path.exists(module): + msg = "Failed to find application, did you mean '%s:%s'?" + raise ImportError(msg % (module.rsplit(".", 1)[0], obj)) + raise + + is_debug = logging.root.level == logging.DEBUG + try: + app = getattr(mod, obj) + except AttributeError: + if is_debug: + traceback.print_exception(*sys.exc_info()) + raise AppImportError("Failed to find application object %r in %r" % (obj, module)) + + if app is None: + raise AppImportError("Failed to find application object: %r" % obj) + + if not callable(app): + raise AppImportError("Application object must be callable.") + return app + + +def getcwd(): + # get current path, try to use PWD env first + try: + a = os.stat(os.environ['PWD']) + b = os.stat(os.getcwd()) + if a.st_ino == b.st_ino and a.st_dev == b.st_dev: + cwd = os.environ['PWD'] + else: + cwd = os.getcwd() + except: + cwd = os.getcwd() + return cwd + + +def http_date(timestamp=None): + """Return the current date and time formatted for a message header.""" + if timestamp is None: + timestamp = time.time() + s = email.utils.formatdate(timestamp, localtime=False, usegmt=True) + return s + + +def is_hoppish(header): + return header.lower().strip() in hop_headers + + +def daemonize(enable_stdio_inheritance=False): + """\ + Standard daemonization of a process. + http://www.svbug.com/documentation/comp.unix.programmer-FAQ/faq_2.html#SEC16 + """ + if 'GUNICORN_FD' not in os.environ: + if os.fork(): + os._exit(0) + os.setsid() + + if os.fork(): + os._exit(0) + + os.umask(0o22) + + # In both the following any file descriptors above stdin + # stdout and stderr are left untouched. The inheritance + # option simply allows one to have output go to a file + # specified by way of shell redirection when not wanting + # to use --error-log option. + + if not enable_stdio_inheritance: + # Remap all of stdin, stdout and stderr on to + # /dev/null. The expectation is that users have + # specified the --error-log option. + + closerange(0, 3) + + fd_null = os.open(REDIRECT_TO, os.O_RDWR) + + if fd_null != 0: + os.dup2(fd_null, 0) + + os.dup2(fd_null, 1) + os.dup2(fd_null, 2) + + else: + fd_null = os.open(REDIRECT_TO, os.O_RDWR) + + # Always redirect stdin to /dev/null as we would + # never expect to need to read interactive input. + + if fd_null != 0: + os.close(0) + os.dup2(fd_null, 0) + + # If stdout and stderr are still connected to + # their original file descriptors we check to see + # if they are associated with terminal devices. + # When they are we map them to /dev/null so that + # are still detached from any controlling terminal + # properly. If not we preserve them as they are. + # + # If stdin and stdout were not hooked up to the + # original file descriptors, then all bets are + # off and all we can really do is leave them as + # they were. + # + # This will allow 'gunicorn ... > output.log 2>&1' + # to work with stdout/stderr going to the file + # as expected. + # + # Note that if using --error-log option, the log + # file specified through shell redirection will + # only be used up until the log file specified + # by the option takes over. As it replaces stdout + # and stderr at the file descriptor level, then + # anything using stdout or stderr, including having + # cached a reference to them, will still work. + + def redirect(stream, fd_expect): + try: + fd = stream.fileno() + if fd == fd_expect and stream.isatty(): + os.close(fd) + os.dup2(fd_null, fd) + except AttributeError: + pass + + redirect(sys.stdout, 1) + redirect(sys.stderr, 2) + + +def seed(): + try: + random.seed(os.urandom(64)) + except NotImplementedError: + random.seed('%s.%s' % (time.time(), os.getpid())) + + +def check_is_writeable(path): + try: + f = open(path, 'a') + except IOError as e: + raise RuntimeError("Error: '%s' isn't writable [%r]" % (path, e)) + f.close() + + +def to_bytestring(value, encoding="utf8"): + """Converts a string argument to a byte string""" + if isinstance(value, bytes): + return value + if not isinstance(value, str): + raise TypeError('%r is not a string' % value) + + return value.encode(encoding) + + +def has_fileno(obj): + if not hasattr(obj, "fileno"): + return False + + # check BytesIO case and maybe others + try: + obj.fileno() + except (AttributeError, IOError, io.UnsupportedOperation): + return False + + return True + + +def warn(msg): + print("!!!", file=sys.stderr) + + lines = msg.splitlines() + for i, line in enumerate(lines): + if i == 0: + line = "WARNING: %s" % line + print("!!! %s" % line, file=sys.stderr) + + print("!!!\n", file=sys.stderr) + sys.stderr.flush() + + +def make_fail_app(msg): + msg = to_bytestring(msg) + + def app(environ, start_response): + start_response("500 Internal Server Error", [ + ("Content-Type", "text/plain"), + ("Content-Length", str(len(msg))) + ]) + return [msg] + + return app + + +def split_request_uri(uri): + if uri.startswith("//"): + # When the path starts with //, urlsplit considers it as a + # relative uri while the RFC says we should consider it as abs_path + # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2 + # We use temporary dot prefix to workaround this behaviour + parts = urllib.parse.urlsplit("." + uri) + return parts._replace(path=parts.path[1:]) + + return urllib.parse.urlsplit(uri) + + +# From six.reraise +def reraise(tp, value, tb=None): + try: + if value is None: + value = tp() + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + finally: + value = None + tb = None + + +def bytes_to_str(b): + if isinstance(b, str): + return b + return str(b, 'latin1') + + +def unquote_to_wsgi_str(string): + return urllib.parse.unquote_to_bytes(string).decode('latin-1') diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__init__.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__init__.py new file mode 100644 index 0000000..ae753e1 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__init__.py @@ -0,0 +1,15 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +# supported gunicorn workers. +SUPPORTED_WORKERS = { + "sync": "gunicorn.workers.sync.SyncWorker", + "eventlet": "gunicorn.workers.geventlet.EventletWorker", + "gevent": "gunicorn.workers.ggevent.GeventWorker", + "gevent_wsgi": "gunicorn.workers.ggevent.GeventPyWSGIWorker", + "gevent_pywsgi": "gunicorn.workers.ggevent.GeventPyWSGIWorker", + "tornado": "gunicorn.workers.gtornado.TornadoWorker", + "gthread": "gunicorn.workers.gthread.ThreadWorker", +} diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/__init__.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cf10ed18c70491f12e5941f87d89517e132e8b2 GIT binary patch literal 511 zcmZ?b<>g`kf-^=JV}qC&7#@Q-Fu(z1H~?|61dvE!NMTH2N?`^Kv_U#c(A)CRIxgy;u4^96I1f_LLfA5%S$qfQWI13LckP6nI`)! z7LX64IAETLVuQFbiW@@5mlvmJM)5*91(jefJJil7_H>A$ewvI?g2ABy0scWDt}gN6 z{z2ZZLBT5-ihvOTA%5BGm*f`c7i1RbX66-_BcjkmV3b2bUq3!R hGcU6wK3=b&@)n0pZhlH>PO2R!GK+bD1QR0y0ssQqscZlM literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/base.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/base.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..415f4c4afcc2e0000bee0edb7c7354459da0e058 GIT binary patch literal 7395 zcmb7JTWlLwdY&7H!;2`2l4Z%a%x2eh*iGalXt!I}>n5?SSb(FrmQrV@ap@7ykQ$1d zq0c$ABrdrRk+BVmrbyAgbg>UK_Ni}+qCnfl_N^~1f&%+gU>@7P@q z7NtD@ne(6jT;{+3$M4O}6*c_6eEXM=zw=E^`&a5re->We!6Uu|U>eiAnwPe^r>nl< z8LBlsQ?-_7sW#{3&>CI4XM46zbIfkO=Xj2Kx4MO1(JQL=T({IKdu8=*cjtN)uhN_M z=6hAI+FS4zdNr@sTl5xtOWsoNoOiCb>@D}sd*>B>zPr*}^;UZqybG%DbT9TUd6(3C zp?kS^#k-xsjB8OX2~;62a%h=q|P^w!q> zyPU@y@76$u-Fh)Ow;uDIkg*_oz~h6%hr!c9AY?MP5k2#}A-fm&Ea1t)sqUuV3zFIt zwY~k|cLOfMI7+G+PAzpmjE`93wa#jW2-#q#`Gb;wLvd{D?Ez%Uck3|{U)(( z`ZMwJ4j%D`0D(p-0d>%s0cM*M^M!UtJJLO?tw9+qmV2&wHnUkCZJs%-fYwPx;}uw$ z&7ogp6*iBy#HwroZJE{BBHB5&#Ll6uuw`~0?L1pyt7xn20=tNIfn8#k(bm`%2=|r5 zP7mDFaWMKBcx*hk@rVlmZEd7Iu8no6Nt}A5FKb7}pBPUq%+`mwt&R7u3NR|)4x}$7 zPizskBfkrjvG!)7AN+;JSFy_1zja;q`q%qm|BWyb((iWP=r!MDPY3ty*O3d1`cuSUnu{(1|#@He3$T<&=HcF8r zE1h|IW3*m%lm}dpwUK>9`z|sQ9JYu5LxOEd?Z2a&|wxETns=5DlToCnv0>$_2aWig}Y?*&s5 zcRyq&=I{DZI}q++Jh;~Fy8AxX!UXIncYW!Gk^AI{2)eDcFbZWO+vTr090w}Zs&hb*!B1oI+p?gdg{px;mOpXKIFt5pl2F^A8$4^*4f(RN)a%pcC3MF3@xd1PdVvKrDr-4N6o+uo(24Hs!y2$JbB`ZpczLjRb8l| z+w#LMDW2aX?*K1BdOur9Z6bZK_d4l0G+RLQCv+Q1+#7Isa8l{%!Nsw*Zq^O{tN7r= zj-a!x!q12#w}QA z#@Lzpg4>zlyD`|sPul89{t|zV#Q_Omg=ZjEOhFJ2A_mjn2_Tpde3-Eh{v~Bh-{&%H z4!S;vT)=RlqUk9{>B-_|EH@wn#91uKvXtPZ+Gp}XbpHgyiW$Rzo^dOW@f;qL=-vk3 zK7-bEbpHCmtLfXsps@M4_K7jp$HvHzX2%-oH?^nBk2IO<*orEzprc@c>7ScA#wJD5 zU1?5AFR*H(tX3>zt(CEf(YcZNLRWN^^zG@+Bkf=XYs`bDGPXcd8CgX0^hdPUq=K>P zWZ{KIIHJQ-X2z=4*3Z)pHS`xJ725SPZL*ZM_?mNH=)C*~T1#gpvz|NSoLmN_);Yhb zjqOqT1uLT*%YANOl~s(bPA+7tT%4{lx%8RZmw~=<8S7u65tfH#I>TR1wF<7D>}9Ga zr|j>Pex#-X!$nX*NLSLFX#^-qEnAS2L~1tGz8z)P6q!z~yC2Hk*;Fy;2mH1Anb<(# zO9c;F_Q?|{0L2Se={&_d1dj1)e-82G!9r{1gm)sTdUxZ6jPf;6p)EUZY;@(ZV>eOuYe@6f`gD!=v*s8@_Wj= zsPK_*s))-D>3dZ1p;r(e%6d^Bek-$?ld%?=Pz))ETWi_Gy5W_A1IhhHE9?d$aY#lx zesgbov;InYLK6vXk_#bdkr**zVwT`?GCprX1hNtDM@Vurx09FyL};@eGXA#u27$Z* zaXah>iS=OP!CkLPbD}tE?BFzeV4OGC?8YK!02Ler%`}RpewB_D#h$b8BV%YWk#e!D zJ}S*5MPjEC;59nXT-wP}Zm%}&9)BdKFbg(IIIW~W8G2)1v_r4jkA-Z^!TE|0Hoc7=+eQz0q&r02{SvyBPj*8nuf(U%d-t9sdV zObYBpy<#G~>s4dPC>jcvFY6BQ=z$6$fAJ;aoar?sSr3ZQ5Pq~3|s2TnHRPO8Rpl+-pTS!hs3>7ZIcAvy@^b|&~B(Hl^G zYzus1(~I2k3UY_iB&>cWf8zIWu0O(~N+eA;^eX-w-7w0w0YM{^16(qO)l952HJr(m z(l|0PCDXsb%fTg*DMd6CTlz#F0d@@XTTdNC8DP*yiP5nLm-SIPbnFv-6cMM!9rOz) z#*65ePV~#@&t?4z)`!eb^om(;9;KggWbnVjuB3Sj%v?=l4oTeFTu#m^%@L(_GgjI;gwIBapu69Ce6T)+FAB~CXpsa>XdI%IYE9W z?gvrowd-c8q$buwsNhiivxnQoq`$^9P33Eu+GVUFp1k}NQI5-Ml*`~aQ zcODU-GCl?5`*;)J=Xm~yElGH%wxo~0P4wjW(=DM%`UC~E@;!*j%usK$n5_H>wChZ$ z%^$~CPX3nvI)U#Hps31!1K|HWz7L|m!y_C3O}8OXi0=&FNH1Uh5iTbEZy%wKZf>sg z#~`fdj!*2Bvk0U#^8az*4i@@*Jc5D&4vere)3!{^YRM)!75dF(k7D{A=$%wW+c-Be z`xT}m)ip+zG$qnmY0JEHWI+~XNtWeYt8`=_HRa40BRv}DQ%X31hs=^leUESpG=XDe6+SQR7CDo@WclNb)E=%H z!L1GWu&L&pSdr$k%D6zTa8er;I*TKd&97?do~-)0Qsn40e38x;)Ea-RXqQ-Rq<7Ad zi)D*gV+m(DhkGI1tnC%PFnBGM(I~f~jf-*__fRm8&iNyATuOHsmDuu4+Q(!l5^z&g zVk_vcoS-bTRoqSGTgI|BDmPZ;g^>fga^s>p!KG0dw53t;g{5nUOY-vM3ibf~$RP|; zi4`5?gHCA!zKvZVlROdLFTzJ9+E@RHU-$*w{IK+%&)n=Pb-0>c!cGw`-J`nKu8M2J z#pzIbGn*o3^!ISz>t+|e>5y?1*FU((8D3N=gNqteAP~E|>h4(FNU1DZJ1MMBubYPp z*->0159tkb_@{KttJCeXyCJv523uarMRo;c?=WuN)PXT@Zt8|#=Cd!JXG#rhI#Pe z!|h=XMa5Myyu6O&B)xzWsK;HkIW9snE+j4 zaw?iRc{DyxfMN_M7thIQaPkP8>Lc8KA?$Uj`;>sX!pgB=XMp=PFs|oI{(uGs1QrOq zN}vjm*i;q{ARJ`w-aOAP$Q$Ujaoe_C%WkWJ*mn6~9GmT6B~%QEC?d z)e-&yWTFqCAyuP4Tet9MAPYx}@Li!yT|E`LjswNCPiQ5k1B1E(VK zRM?{e_zXXI3%CL_HjUcG*@LN^YO}sb7nf9$HX2E>(Ll{RK$g}>$_=Dyem5J*30$~I z{`<5I1sVPZfi(hjBc>`V{sFz+BR~lh-zCr_;1i&r#-9_QgPl06N;XuUv4jD-$P_LB z-H(2;_gQr4u5 z%UhU@PV3FI*u5~rr_vW|X^YG0^qSg^cRE2+s?UBI_Y&u3D!g0d00doRr<$L_GW4|! N{e3f!S`~HZe*um~VUqv= literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/base_async.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/base_async.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..742bbd3e9af1324a59f2e93e6a317a322f488a13 GIT binary patch literal 3810 zcmb7H&2JpH6({FwXFn~kWm%GCW#gb}Hi+e<2%3x0R<$;@3s-g}w{ivv2ICn@n$_&g zn&ev2VpJ5CfdDxZY|KipywQV2#U5xUJDe+ztBU`_c*h%th5EX3qEolAKw?r zAITp!n>7NzufFrw&wg{2kiX-{^k+fi2T;UIAQ6dZLI%Vm6x&8ZJ*sQNGjwfwrmii| z(zQKsJg1bc3>*W-4P4JHIn_bUtCj8gprL!4UXv2mIwszwACbt6td}IRShGKKYmhQcKeKFzJJ4VRJ@kyv$u^B>WW032L#-7&v?J#w@$9G) zxllV%HL5{f`J7n9bHP$w)mOz~8g6BLkMWR}iqQa;OHjlT5J`?npXM|-zMz!kq;K@i zocNFmP(s(cma@fY$hdNSKTc!m`^pTrcf9t#R_upanzB&FSt`1wvII-El@;(Ep`5*a ztRdK{?}tesgzx{J{B!lT91L#{5@L29b5x871=ogUNB1EdLtY`B6V3@E0 zOC^hXoM*gCc?Cpy{fsoArRq3o*+}}KJXi#VFn|y`zINV&b26ds2NA5XXeV4~%XSx9bNAGsAO*V@ zdVb+PA)k=+cQB#}(*L?3ZTv^+F-W)im-cEWl;5PVXu#{4{$<&oTsb9Qz!zxzImpav ziM9VC@gYcD)e_H3tFsW#T#+BJ3mLlLrSSwfCp2}>+5bm5_FnGxuSMnpdN#jjfMI^v> z1aib#Cro14wVfyyudryP^DQx+yPISpPIo%5^EpDn_^J@exem~h2^NiS=)Dixvycfr zcyseXhqGrRCgjSvvzdi^Om<*9X8gR=nZ$y2@O7&&UNAXsoptpd-G9{UE-PzS%AwcX zDAYd+xB$ftxToqnObW1-1_P$5dyEZ(B!146m9hh=TE&LV17#-Jjaf~y@x`%>>w<3&-BvgG0##2%|gD~I|$iOYig7(YWp1V4s2~c@Ov8@4>$bY!;h7% zQ?6`~NHb;YoTysw?!)!vhApP~1IRx2uy{WZ~AzE0a3HM`XjPUqL(lhB%pW0k$jv_Da7A2LOU{3*d|L zKScH>8GkA-Vinom>IfH^5SD3XXC%ccaQN!rgN27Ng+6s7$V&0#Nezt`^&3ld9O;%|jS4%y~kL991)jb1HBI-bM%+?>22JN-9x z#>~PSuswHX<;y|`SOzFBeA9ktV2{Y*9ARJ~Y)^OMv@^_voWf3LH_P_AZ*jcUC^OCW zHFSA(faa-)vd|jrR&ZA`Wu#o$8pyoHAUK#x3BG_TEJQ4?zMb)q!G#gApepqW(F&3iw4>~E}XZFr6I z`RUe+8{}QeI1;tumVe!g<gB(Mvo9 zLIAcb_#=$fpkR%_3H#*U^bn^ZWW&h2)Xb?sQLaNi$<`+X`l%+qN>}ek!LmXdMp0lN2 jNZPko;S??XlyL79Ir<)+_yWVixzc}_6`Z-Y;h6sh6_?l$ literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/geventlet.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/geventlet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d96dfdda844a73fa3bda39cedbad1411b429dda GIT binary patch literal 4488 zcmb_f&6C_l74O!^jOJs<>&@D6Yy(OvP#GZW*cC#6K;p!k56ZP9wqYGrf-FltGn&;% zdGk>DhE!S_`TN5dc8@(1*y8#>Tb1OzxR9Z z{rb(7l_taW_iJB#%vKru2fZvW4~;ia)K{nymhg;?c)&Tet;`B6^RxroJe|OqwoS_o z+-;U$c9^K`H04ds=oaH_^DNEMH`9nLnlvuY}_uQA*HS6-SK8~bLqik#c zns_L3oeAyl7IH^OUy28lR0`!E54^N-?d6TDej)uq+8+ps?^p1>65&H3Ra)fxwQ5S& zDxJaPzA9UNDX{85iYUSC);siiyNGv$#%oi{Xf!UeG#7X~bN%M6&FeQl4Bx%Jb>rsd z4Vr&lP4jr$$P+sxGASbWgoH!)?F0pgRYz{$?=yvkjLGX zsTSROX%(vUl*p4_nu)UhtJ|AW7P53A*;l12q|A%5wt4-X>+fyJIzH|KHoc^n=)mbE zXK*7EyPEmX#xvKL43OUZ-D`0ADZBv0c) z=8qedrPP)F(nK5MX}K0I-@>JY-@?kOgNktr_o}%&mOPK1*rtA5Y^+0J$`dGG7<|y?aY-Y{W$lh^Hct#fG9q@7?poUM$Ai zETspL_EYUgT8q&bf5O+pBF%k05dOF*GK`ou%>F}vcaX*dANDDBjZFU1I%ciDjAGH7 zWWE|qbW-f*YQyw*?JZp0cIhpp3L3^mX#JpJ+~a*TC4oF>_JxioQer!0Es9Cf(pBSV zH!mGH%}&`lVQO8B%f@ZgMqi~HXN3|$eK$%8MP09S6#TBN4Wc~BM9_jZs3=~TZr zN|9k-mkvhplPF1KY4x>%W>uYoVC9(;|0PAffKGJ*74zD>X%WWSykqWF?%|ftW9%4d zgt%j*kq1vN@3(;lMks*w;l*=K?Ynr(Un5^0+Q7{pfEPJzy-BF+2gqhJSk`B08;GzTOQu<~5Q8jJG_brV7{7&Lrfa5o!nJisE>9uT z+LCPy;@5RVIXIM*Exem}bK=Jo@T37$XB_Exa2&5bpp`9DjLQwwPyE`Zeq1U+C0M`{ zhHT9f3)#;8jP-b8C(fr{;Fz|X)X;WKyPkMx*G#*SG|{dvvZrVID1&-IW066dpCO9` zEo|p(+1Xqq$3-rpgg_TPNlv4Ri)c_DBIIgoZkwlbh&Q7YzSVUl=`E;FkTQ`U<BBjFcaU799!mN)-u;q4YeE-=~+xhzP@oDXw zy-_Y(#t_=u+#>xiHE+wS7?&@jD%)wE>ToQJSSZ!yMpistp$W&3lt0F6grdk~r0V@k zrzJbF%oDMVg7>jZgb32|5L!kqUAhSA+Sp${gV~i}txA6(c$eY5sxBbsQ8tb5QVRwH;gj^U;$lteO@6Rjq)7g7=9>2Zfv{ zMs-N|lA=cu0!Q#+oNW!Sm<~)+%ZrK4u^a z6mU#*0)aOJ$V=D297l*kr@g6sjg~SnT3xcwZ~bt1AjS4x9ic%I*$#0`O zaQh@^;0(Y`0&h83a$WMMv=GMEX$4c6bY#m(K0%iv95N7vHh|Sc-Q=Ftq z<*KsS8T!&Nnl7~{jhC(WaFmt0ItaFJO>hJmiRx`-yweYn3yXikO7d)ZjjHdV3N9_rBO8lD;>P_5tRtcW zwIt83$QXgmuscIM%zjUp`LV6N*D7QDf-tPUkBW?q8)V;5eX9)vd)6x6==LmVu;o4N It$EIW0FmQH9smFU literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/ggevent.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/ggevent.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e821f06d5080560aeb90dc1e1ae24280adecc67 GIT binary patch literal 5975 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 NR329RnKLuae*tPaeBS^7 literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/gthread.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/gthread.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d6c4467bef6588e6644bc41c64cc1323dbdaa92 GIT binary patch literal 8570 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 UeAL;R1|v|9MYHA7D9x7sFS_F{5&!@I literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/sync.cpython-37.pyc b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/__pycache__/sync.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8d75090a36972376ca3e275e4d3504da3605f4c GIT binary patch literal 5055 zcmaJ_OKcm*8J?MaaQP4=(Xt{rPO>qYG)x`2c_3|*BDH1FiBXp}Bqd50Nw*AlCGoXO z%`PK}SO!I$Q&AW>1ZWRMN&&g_no|!&&{I#n6exPwQ-Pk+V-G#_)bF3AD9UiU#QgJq z{I75R;riTMf#LhhOMiX;Z;vzfPpX`LIttg3qR&A*=J77;F^6#~i!OJ#%7r6Tt~r{@ zbw^jZ;TS469aH7Gp5<7Rx%r+YuuiYw6ecajUdbs<%5%N4>YaDyIeU|Nnx}ulJl$Wo zuQ`jT8=i@}>Cd+-Xu05tEmqBajWe<;Pc5$z`*Ex1*PGOG`f(JlBSi}!KBKea+#F}7 z*;-oMio^a+qZPM;z2VEYf7JB*aVrdL*=R++XUCx(VT65{4Y7AaX*cX<7zBP(jjLDn z)NgWECkQeK20)1^kAKXN;|7CpgC+d5z-l4=5aOf&*{} zp7@w2tS$D~9=JZyMje$8ordFggoV5 zq$)w^7`5B=?aee7K}UX!=Gyv=ja#V*q%z5>F3I=O964t=h*M4aamxLN)RF46=~EaP zJqg0N;1;i_RN*C2;S1bEDsWTid^kU&C7RbHcIcy=>`>|GTPQ#pq#bd>I-0am)5f|7 zU6I@g13V2@r`Ly1-)l&iirs`U?fKqSJK7(_gbKD79tN-3&qTMjtA?ZZ`z=pChK1AI zo*z>!)w&@pvlZ-yRjzn_n6>#<tWK19nS-B8GyFU>_|fJ^&`hk6 zVT{Dl1C+V^4a^aYa(29c(!|LQOE9a~U{*Se%9|L~Wtfi<8*LLQhh*()ot)f$l)+%7 z{0WOBx#w{iwE_$r&bz}7N?5gsRX^j{Gjrf~(Mm?ATv-`ewInZ-xD3U*B*ap#moC(T z4_h(}dJub!%u3=SVyRiX@#c-&^|VyGdADA_v3_@RyS9-QYdd$}zO%7@=kCoP%V%kg zD?~JqiGfM79l1#4X(CgURoL zAp4lY0bPTnoxbJq5kFcXpMku~1lD5#D28+oDm%~+_1x#4*3sn~kQOc}>I(`e8(CS& zOt0_JX&L*+k7n@H%q)?NUe194AN)YBQS~ZFRhy9!j~=#D4N?g(EFx($t)Q2987NT_ z!}58Co5UA=Ii%^e^mhOt0AK%<55GFD6Su&HtFdSU4R&z>d!j`b6|C#m;sIlvxuEuVFxjJyJ(l97_C=)SUD3&5|98}ik9n5T z{d1EM%N>C}IoU0*`bv{pfokVv5WIrDR@7d9n(Va%>Hfdd;gY5`;??nD7A8$D?P8r` zA^D*%-KgdH+r#H??**YmklL4iuMrQVZ)fq2?X{w_5OocA*KqkJLMFP+&bKSG9bSy0 z?o0<(L3rg2pHQfb)x)MAsmWVgcWmh&4E!iw8`@jy!najOFgt2GVpSdR{H~affNofx zcGW1vs9s97=I)+j;_|~`QjJLQP&WE*7FIY#w78*)%@K_3$8q18+suxFn;UXT^}s)h z({dIJx|2hsraE5a6zbtmAgql>+>nGZsp0t_4EEAFdH~#xec7OJKDEGNb{SowL360O zwav}Dn{Msyt<+GGNlTMG)Y4~&h{#8UO9gdvZPvDG+i8CKqDb?#)5nD@W9@1#!vS?; zRnQWNj7qYm7;`l1vLVZ zvbc=$v*KKkoAJ`5n~XlX&FFaQM*B0+q{T*f(2YzW%JBGKuyovPiNcF4ls{pkoC;|X z#>40M*gR1vdtxB)H%CTdj&tOp34pi_7@kM#LZbZf;0xSwW`+y&*uZ&mD{KVx z#y*wA1gaTH;S?9*3yI|!SohzFmCYgl3w{Z|T~dB~DZ8uVi|yt3vGK|YdjM__Oz&gF zsv7Z&Y(xSX$staCN#(TLKdI13%l5%8%hO%piS)~Y^!Ta!jKcS< zMrd%njMKBRO_C?cWTy|VOwaJuSz9m8eiB(^dha`4HF;geG%w_AbT52N_h z6Yc#l>{OqYFJrn>1Z16dNP0h}S`Z%M4S?P7YD44@`)LsYHhDk2pq(OOx2EqZ2bAuS=hY^uc>EZ9J|JOhNBpM}Zv0*e586G^*@LC2y-a0B=Q?K!2> zZhCD!6kEveW98o=MRgE@4gwE?jRLRe3PcbAQwv4EB|%}Ag_dPiT2ODWvQ|QG2|s#| znHVJiItzTbIuo6ohu}K6qgX`}#7L6}#Wq<0uR?hWi?RUeMJf@(sk6?UUq$ok*-oJj zy}#5yI+n0Z>w=ZDp0HM|dFzU#-s+MvsVqvRq4FY;Eh4WFxd-CRo&LkJMwf{sG<7QH z+SbS#<(uaR(;pBDznzQI!IOVx);?&!LUNN@s#8^2hheZ;38M>6!LPE@z>9oE8DP!v#;QzhmI)4?|hpEDmy+9SoRp z3K>T6nc*UqOTPHvsicsQ!41Q5W$bx6Rx|HfbK8gOKA0J+80%AG#|o9+!+ECTH2hl1 zTpCx0X%WRqXjauBX}-uz`@ti>=>g-+vn0-D#)(8; zgqg80G}tA%0>`R|vn-SY$5<*%BEy4d;5o#>&QN_&bqzAk05Uhv4L} zh>L?bQ+k{v2WfCmJewCE9j+6y5tficT$nMMnUp#$iX0VO_(Jcfr`WO8Wt}$t%!wlQCG# z3jxh~4=$*BR_XHQ2GEwpe^8-iokIK%!xXM)g-HT5Y=hwHxHY&>w&HCi0J}KL|7WN@ z@b!vNc=Xv;sOy`j)r~zGxY%LXvc7LRz7K_*Cn)!P|Ji(;G$-;c@FCwu@-7lguSDNl z1+GhtRhAscE_@1;<1+UR*K)bb>-|BuDVAF#V;$u(m0d9M-1Rgx)9I*loMX@Z@w+b{ xfAhn`?@b44E45n0`cz^k7$<)^4Fg>}y$XeKKX2ah1vZE3AruNf)?+RV%fBoZhrs{< literal 0 HcmV?d00001 diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base.py new file mode 100644 index 0000000..f95994b --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base.py @@ -0,0 +1,267 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import io +import os +import signal +import sys +import time +import traceback +from datetime import datetime +from random import randint +from ssl import SSLError + +from gunicorn import util +from gunicorn.http.errors import ( + ForbiddenProxyRequest, InvalidHeader, + InvalidHeaderName, InvalidHTTPVersion, + InvalidProxyLine, InvalidRequestLine, + InvalidRequestMethod, InvalidSchemeHeaders, + LimitRequestHeaders, LimitRequestLine, +) +from gunicorn.http.wsgi import Response, default_environ +from gunicorn.reloader import reloader_engines +from gunicorn.workers.workertmp import WorkerTmp + + +class Worker(object): + + SIGNALS = [getattr(signal, "SIG%s" % x) + for x in "ABRT HUP QUIT INT TERM USR1 USR2 WINCH CHLD".split()] + + PIPE = [] + + def __init__(self, age, ppid, sockets, app, timeout, cfg, log): + """\ + This is called pre-fork so it shouldn't do anything to the + current process. If there's a need to make process wide + changes you'll want to do that in ``self.init_process()``. + """ + self.age = age + self.pid = "[booting]" + self.ppid = ppid + self.sockets = sockets + self.app = app + self.timeout = timeout + self.cfg = cfg + self.booted = False + self.aborted = False + self.reloader = None + + self.nr = 0 + + if cfg.max_requests > 0: + jitter = randint(0, cfg.max_requests_jitter) + self.max_requests = cfg.max_requests + jitter + else: + self.max_requests = sys.maxsize + + self.alive = True + self.log = log + self.tmp = WorkerTmp(cfg) + + def __str__(self): + return "" % self.pid + + def notify(self): + """\ + Your worker subclass must arrange to have this method called + once every ``self.timeout`` seconds. If you fail in accomplishing + this task, the master process will murder your workers. + """ + self.tmp.notify() + + def run(self): + """\ + This is the mainloop of a worker process. You should override + this method in a subclass to provide the intended behaviour + for your particular evil schemes. + """ + raise NotImplementedError() + + def init_process(self): + """\ + If you override this method in a subclass, the last statement + in the function should be to call this method with + super().init_process() so that the ``run()`` loop is initiated. + """ + + # set environment' variables + if self.cfg.env: + for k, v in self.cfg.env.items(): + os.environ[k] = v + + util.set_owner_process(self.cfg.uid, self.cfg.gid, + initgroups=self.cfg.initgroups) + + # Reseed the random number generator + util.seed() + + # For waking ourselves up + self.PIPE = os.pipe() + for p in self.PIPE: + util.set_non_blocking(p) + util.close_on_exec(p) + + # Prevent fd inheritance + for s in self.sockets: + util.close_on_exec(s) + util.close_on_exec(self.tmp.fileno()) + + self.wait_fds = self.sockets + [self.PIPE[0]] + + self.log.close_on_exec() + + self.init_signals() + + # start the reloader + if self.cfg.reload: + def changed(fname): + self.log.info("Worker reloading: %s modified", fname) + self.alive = False + self.cfg.worker_int(self) + time.sleep(0.1) + sys.exit(0) + + reloader_cls = reloader_engines[self.cfg.reload_engine] + self.reloader = reloader_cls(extra_files=self.cfg.reload_extra_files, + callback=changed) + self.reloader.start() + + self.load_wsgi() + self.cfg.post_worker_init(self) + + # Enter main run loop + self.booted = True + self.run() + + def load_wsgi(self): + try: + self.wsgi = self.app.wsgi() + except SyntaxError as e: + if not self.cfg.reload: + raise + + self.log.exception(e) + + # fix from PR #1228 + # storing the traceback into exc_tb will create a circular reference. + # per https://docs.python.org/2/library/sys.html#sys.exc_info warning, + # delete the traceback after use. + try: + _, exc_val, exc_tb = sys.exc_info() + self.reloader.add_extra_file(exc_val.filename) + + tb_string = io.StringIO() + traceback.print_tb(exc_tb, file=tb_string) + self.wsgi = util.make_fail_app(tb_string.getvalue()) + finally: + del exc_tb + + def init_signals(self): + # reset signaling + for s in self.SIGNALS: + signal.signal(s, signal.SIG_DFL) + # init new signaling + signal.signal(signal.SIGQUIT, self.handle_quit) + signal.signal(signal.SIGTERM, self.handle_exit) + signal.signal(signal.SIGINT, self.handle_quit) + signal.signal(signal.SIGWINCH, self.handle_winch) + signal.signal(signal.SIGUSR1, self.handle_usr1) + signal.signal(signal.SIGABRT, self.handle_abort) + + # Don't let SIGTERM and SIGUSR1 disturb active requests + # by interrupting system calls + signal.siginterrupt(signal.SIGTERM, False) + signal.siginterrupt(signal.SIGUSR1, False) + + if hasattr(signal, 'set_wakeup_fd'): + signal.set_wakeup_fd(self.PIPE[1]) + + def handle_usr1(self, sig, frame): + self.log.reopen_files() + + def handle_exit(self, sig, frame): + self.alive = False + + def handle_quit(self, sig, frame): + self.alive = False + # worker_int callback + self.cfg.worker_int(self) + time.sleep(0.1) + sys.exit(0) + + def handle_abort(self, sig, frame): + self.alive = False + self.cfg.worker_abort(self) + sys.exit(1) + + def handle_error(self, req, client, addr, exc): + request_start = datetime.now() + addr = addr or ('', -1) # unix socket case + if isinstance(exc, (InvalidRequestLine, InvalidRequestMethod, + InvalidHTTPVersion, InvalidHeader, InvalidHeaderName, + LimitRequestLine, LimitRequestHeaders, + InvalidProxyLine, ForbiddenProxyRequest, + InvalidSchemeHeaders, + SSLError)): + + status_int = 400 + reason = "Bad Request" + + if isinstance(exc, InvalidRequestLine): + mesg = "Invalid Request Line '%s'" % str(exc) + elif isinstance(exc, InvalidRequestMethod): + mesg = "Invalid Method '%s'" % str(exc) + elif isinstance(exc, InvalidHTTPVersion): + mesg = "Invalid HTTP Version '%s'" % str(exc) + elif isinstance(exc, (InvalidHeaderName, InvalidHeader,)): + mesg = "%s" % str(exc) + if not req and hasattr(exc, "req"): + req = exc.req # for access log + elif isinstance(exc, LimitRequestLine): + mesg = "%s" % str(exc) + elif isinstance(exc, LimitRequestHeaders): + mesg = "Error parsing headers: '%s'" % str(exc) + elif isinstance(exc, InvalidProxyLine): + mesg = "'%s'" % str(exc) + elif isinstance(exc, ForbiddenProxyRequest): + reason = "Forbidden" + mesg = "Request forbidden" + status_int = 403 + elif isinstance(exc, InvalidSchemeHeaders): + mesg = "%s" % str(exc) + elif isinstance(exc, SSLError): + reason = "Forbidden" + mesg = "'%s'" % str(exc) + status_int = 403 + + msg = "Invalid request from ip={ip}: {error}" + self.log.debug(msg.format(ip=addr[0], error=str(exc))) + else: + if hasattr(req, "uri"): + self.log.exception("Error handling request %s", req.uri) + status_int = 500 + reason = "Internal Server Error" + mesg = "" + + if req is not None: + request_time = datetime.now() - request_start + environ = default_environ(req, client, self.cfg) + environ['REMOTE_ADDR'] = addr[0] + environ['REMOTE_PORT'] = str(addr[1]) + resp = Response(req, client, self.cfg) + resp.status = "%s %s" % (status_int, reason) + resp.response_length = len(mesg) + self.log.access(resp, req, environ, request_time) + + try: + util.write_error(client, status_int, reason, mesg) + except: + self.log.debug("Failed to send error message.") + + def handle_winch(self, sig, fname): + # Ignore SIGWINCH in worker. Fixes a crash on OpenBSD. + self.log.debug("worker: SIGWINCH ignored.") diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base_async.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base_async.py new file mode 100644 index 0000000..ebd0fc1 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/base_async.py @@ -0,0 +1,146 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +from datetime import datetime +import errno +import socket +import ssl +import sys + +import gunicorn.http as http +import gunicorn.http.wsgi as wsgi +import gunicorn.util as util +import gunicorn.workers.base as base + +ALREADY_HANDLED = object() + + +class AsyncWorker(base.Worker): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.worker_connections = self.cfg.worker_connections + + def timeout_ctx(self): + raise NotImplementedError() + + def is_already_handled(self, respiter): + # some workers will need to overload this function to raise a StopIteration + return respiter == ALREADY_HANDLED + + def handle(self, listener, client, addr): + req = None + try: + parser = http.RequestParser(self.cfg, client) + try: + listener_name = listener.getsockname() + if not self.cfg.keepalive: + req = next(parser) + self.handle_request(listener_name, req, client, addr) + else: + # keepalive loop + proxy_protocol_info = {} + while True: + req = None + with self.timeout_ctx(): + req = next(parser) + if not req: + break + if req.proxy_protocol_info: + proxy_protocol_info = req.proxy_protocol_info + else: + req.proxy_protocol_info = proxy_protocol_info + self.handle_request(listener_name, req, client, addr) + except http.errors.NoMoreData as e: + self.log.debug("Ignored premature client disconnection. %s", e) + except StopIteration as e: + self.log.debug("Closing connection. %s", e) + except ssl.SSLError: + # pass to next try-except level + util.reraise(*sys.exc_info()) + except EnvironmentError: + # pass to next try-except level + util.reraise(*sys.exc_info()) + except Exception as e: + self.handle_error(req, client, addr, e) + except ssl.SSLError as e: + if e.args[0] == ssl.SSL_ERROR_EOF: + self.log.debug("ssl connection closed") + client.close() + else: + self.log.debug("Error processing SSL request.") + self.handle_error(req, client, addr, e) + except EnvironmentError as e: + if e.errno not in (errno.EPIPE, errno.ECONNRESET): + self.log.exception("Socket error processing request.") + else: + if e.errno == errno.ECONNRESET: + self.log.debug("Ignoring connection reset") + else: + self.log.debug("Ignoring EPIPE") + except Exception as e: + self.handle_error(req, client, addr, e) + finally: + util.close(client) + + def handle_request(self, listener_name, req, sock, addr): + request_start = datetime.now() + environ = {} + resp = None + try: + self.cfg.pre_request(self, req) + resp, environ = wsgi.create(req, sock, addr, + listener_name, self.cfg) + environ["wsgi.multithread"] = True + self.nr += 1 + if self.alive and self.nr >= self.max_requests: + self.log.info("Autorestarting worker after current request.") + resp.force_close() + self.alive = False + + if not self.cfg.keepalive: + resp.force_close() + + respiter = self.wsgi(environ, resp.start_response) + if self.is_already_handled(respiter): + return False + try: + if isinstance(respiter, environ['wsgi.file_wrapper']): + resp.write_file(respiter) + else: + for item in respiter: + resp.write(item) + resp.close() + request_time = datetime.now() - request_start + self.log.access(resp, req, environ, request_time) + finally: + if hasattr(respiter, "close"): + respiter.close() + if resp.should_close(): + raise StopIteration() + except StopIteration: + raise + except EnvironmentError: + # If the original exception was a socket.error we delegate + # handling it to the caller (where handle() might ignore it) + util.reraise(*sys.exc_info()) + except Exception: + if resp and resp.headers_sent: + # If the requests have already been sent, we should close the + # connection to indicate the error. + self.log.exception("Error handling request") + try: + sock.shutdown(socket.SHUT_RDWR) + sock.close() + except EnvironmentError: + pass + raise StopIteration() + raise + finally: + try: + self.cfg.post_request(self, req, environ, resp) + except Exception: + self.log.exception("Exception in post_request hook") + return True diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/geventlet.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/geventlet.py new file mode 100644 index 0000000..968868a --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/geventlet.py @@ -0,0 +1,144 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +from functools import partial +import errno +import os +import sys + +try: + import eventlet +except ImportError: + raise RuntimeError("eventlet worker requires eventlet 0.24.1 or higher") +else: + from pkg_resources import parse_version + if parse_version(eventlet.__version__) < parse_version('0.24.1'): + raise RuntimeError("eventlet worker requires eventlet 0.24.1 or higher") + +from eventlet import hubs, greenthread +from eventlet.greenio import GreenSocket +from eventlet.hubs import trampoline +from eventlet.wsgi import ALREADY_HANDLED as EVENTLET_ALREADY_HANDLED +import greenlet + +from gunicorn.workers.base_async import AsyncWorker + + +def _eventlet_sendfile(fdout, fdin, offset, nbytes): + while True: + try: + return os.sendfile(fdout, fdin, offset, nbytes) + except OSError as e: + if e.args[0] == errno.EAGAIN: + trampoline(fdout, write=True) + else: + raise + + +def _eventlet_serve(sock, handle, concurrency): + """ + Serve requests forever. + + This code is nearly identical to ``eventlet.convenience.serve`` except + that it attempts to join the pool at the end, which allows for gunicorn + graceful shutdowns. + """ + pool = eventlet.greenpool.GreenPool(concurrency) + server_gt = eventlet.greenthread.getcurrent() + + while True: + try: + conn, addr = sock.accept() + gt = pool.spawn(handle, conn, addr) + gt.link(_eventlet_stop, server_gt, conn) + conn, addr, gt = None, None, None + except eventlet.StopServe: + sock.close() + pool.waitall() + return + + +def _eventlet_stop(client, server, conn): + """ + Stop a greenlet handling a request and close its connection. + + This code is lifted from eventlet so as not to depend on undocumented + functions in the library. + """ + try: + try: + client.wait() + finally: + conn.close() + except greenlet.GreenletExit: + pass + except Exception: + greenthread.kill(server, *sys.exc_info()) + + +def patch_sendfile(): + setattr(os, "sendfile", _eventlet_sendfile) + + +class EventletWorker(AsyncWorker): + + def patch(self): + hubs.use_hub() + eventlet.monkey_patch() + patch_sendfile() + + def is_already_handled(self, respiter): + if respiter == EVENTLET_ALREADY_HANDLED: + raise StopIteration() + return super().is_already_handled(respiter) + + def init_process(self): + self.patch() + super().init_process() + + def handle_quit(self, sig, frame): + eventlet.spawn(super().handle_quit, sig, frame) + + def handle_usr1(self, sig, frame): + eventlet.spawn(super().handle_usr1, sig, frame) + + def timeout_ctx(self): + return eventlet.Timeout(self.cfg.keepalive or None, False) + + def handle(self, listener, client, addr): + if self.cfg.is_ssl: + client = eventlet.wrap_ssl(client, server_side=True, + **self.cfg.ssl_options) + + super().handle(listener, client, addr) + + def run(self): + acceptors = [] + for sock in self.sockets: + gsock = GreenSocket(sock) + gsock.setblocking(1) + hfun = partial(self.handle, gsock) + acceptor = eventlet.spawn(_eventlet_serve, gsock, hfun, + self.worker_connections) + + acceptors.append(acceptor) + eventlet.sleep(0.0) + + while self.alive: + self.notify() + eventlet.sleep(1.0) + + self.notify() + try: + with eventlet.Timeout(self.cfg.graceful_timeout) as t: + for a in acceptors: + a.kill(eventlet.StopServe()) + for a in acceptors: + a.wait() + except eventlet.Timeout as te: + if te != t: + raise + for a in acceptors: + a.kill() diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/ggevent.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/ggevent.py new file mode 100644 index 0000000..5dfec5e --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/ggevent.py @@ -0,0 +1,205 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import errno +import os +import sys +from datetime import datetime +from functools import partial +import time + +try: + import gevent +except ImportError: + raise RuntimeError("gevent worker requires gevent 1.4 or higher") +else: + from pkg_resources import parse_version + if parse_version(gevent.__version__) < parse_version('1.4'): + raise RuntimeError("gevent worker requires gevent 1.4 or higher") + +from gevent.pool import Pool +from gevent.server import StreamServer +from gevent import hub, monkey, socket, pywsgi + +import gunicorn +from gunicorn.http.wsgi import base_environ +from gunicorn.workers.base_async import AsyncWorker + +VERSION = "gevent/%s gunicorn/%s" % (gevent.__version__, gunicorn.__version__) + + +def _gevent_sendfile(fdout, fdin, offset, nbytes): + while True: + try: + return os.sendfile(fdout, fdin, offset, nbytes) + except OSError as e: + if e.args[0] == errno.EAGAIN: + socket.wait_write(fdout) + else: + raise + +def patch_sendfile(): + setattr(os, "sendfile", _gevent_sendfile) + + +class GeventWorker(AsyncWorker): + + server_class = None + wsgi_handler = None + + def patch(self): + monkey.patch_all() + + # monkey patch sendfile to make it none blocking + patch_sendfile() + + # patch sockets + sockets = [] + for s in self.sockets: + sockets.append(socket.socket(s.FAMILY, socket.SOCK_STREAM, + fileno=s.sock.fileno())) + self.sockets = sockets + + def notify(self): + super().notify() + if self.ppid != os.getppid(): + self.log.info("Parent changed, shutting down: %s", self) + sys.exit(0) + + def timeout_ctx(self): + return gevent.Timeout(self.cfg.keepalive, False) + + def run(self): + servers = [] + ssl_args = {} + + if self.cfg.is_ssl: + ssl_args = dict(server_side=True, **self.cfg.ssl_options) + + for s in self.sockets: + s.setblocking(1) + pool = Pool(self.worker_connections) + if self.server_class is not None: + environ = base_environ(self.cfg) + environ.update({ + "wsgi.multithread": True, + "SERVER_SOFTWARE": VERSION, + }) + server = self.server_class( + s, application=self.wsgi, spawn=pool, log=self.log, + handler_class=self.wsgi_handler, environ=environ, + **ssl_args) + else: + hfun = partial(self.handle, s) + server = StreamServer(s, handle=hfun, spawn=pool, **ssl_args) + + server.start() + servers.append(server) + + while self.alive: + self.notify() + gevent.sleep(1.0) + + try: + # Stop accepting requests + for server in servers: + if hasattr(server, 'close'): # gevent 1.0 + server.close() + if hasattr(server, 'kill'): # gevent < 1.0 + server.kill() + + # Handle current requests until graceful_timeout + ts = time.time() + while time.time() - ts <= self.cfg.graceful_timeout: + accepting = 0 + for server in servers: + if server.pool.free_count() != server.pool.size: + accepting += 1 + + # if no server is accepting a connection, we can exit + if not accepting: + return + + self.notify() + gevent.sleep(1.0) + + # Force kill all active the handlers + self.log.warning("Worker graceful timeout (pid:%s)" % self.pid) + for server in servers: + server.stop(timeout=1) + except: + pass + + def handle(self, listener, client, addr): + # Connected socket timeout defaults to socket.getdefaulttimeout(). + # This forces to blocking mode. + client.setblocking(1) + super().handle(listener, client, addr) + + def handle_request(self, listener_name, req, sock, addr): + try: + super().handle_request(listener_name, req, sock, addr) + except gevent.GreenletExit: + pass + except SystemExit: + pass + + def handle_quit(self, sig, frame): + # Move this out of the signal handler so we can use + # blocking calls. See #1126 + gevent.spawn(super().handle_quit, sig, frame) + + def handle_usr1(self, sig, frame): + # Make the gevent workers handle the usr1 signal + # by deferring to a new greenlet. See #1645 + gevent.spawn(super().handle_usr1, sig, frame) + + def init_process(self): + self.patch() + hub.reinit() + super().init_process() + + +class GeventResponse(object): + + status = None + headers = None + sent = None + + def __init__(self, status, headers, clength): + self.status = status + self.headers = headers + self.sent = clength + + +class PyWSGIHandler(pywsgi.WSGIHandler): + + def log_request(self): + start = datetime.fromtimestamp(self.time_start) + finish = datetime.fromtimestamp(self.time_finish) + response_time = finish - start + resp_headers = getattr(self, 'response_headers', {}) + resp = GeventResponse(self.status, resp_headers, self.response_length) + if hasattr(self, 'headers'): + req_headers = self.headers.items() + else: + req_headers = [] + self.server.log.access(resp, req_headers, self.environ, response_time) + + def get_environ(self): + env = super().get_environ() + env['gunicorn.sock'] = self.socket + env['RAW_URI'] = self.path + return env + + +class PyWSGIServer(pywsgi.WSGIServer): + pass + + +class GeventPyWSGIWorker(GeventWorker): + "The Gevent StreamServer based workers." + server_class = PyWSGIServer + wsgi_handler = PyWSGIHandler diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gthread.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gthread.py new file mode 100644 index 0000000..5828ee9 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gthread.py @@ -0,0 +1,359 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +# design: +# A threaded worker accepts connections in the main loop, accepted +# connections are added to the thread pool as a connection job. +# Keepalive connections are put back in the loop waiting for an event. +# If no event happen after the keep alive timeout, the connection is +# closed. +# pylint: disable=no-else-break + +import concurrent.futures as futures +import errno +import os +import selectors +import socket +import ssl +import sys +import time +from collections import deque +from datetime import datetime +from functools import partial +from threading import RLock + +from . import base +from .. import http +from .. import util +from ..http import wsgi + + +class TConn(object): + + def __init__(self, cfg, sock, client, server): + self.cfg = cfg + self.sock = sock + self.client = client + self.server = server + + self.timeout = None + self.parser = None + + # set the socket to non blocking + self.sock.setblocking(False) + + def init(self): + self.sock.setblocking(True) + if self.parser is None: + # wrap the socket if needed + if self.cfg.is_ssl: + self.sock = ssl.wrap_socket(self.sock, server_side=True, + **self.cfg.ssl_options) + + # initialize the parser + self.parser = http.RequestParser(self.cfg, self.sock) + + def set_timeout(self): + # set the timeout + self.timeout = time.time() + self.cfg.keepalive + + def close(self): + util.close(self.sock) + + +class ThreadWorker(base.Worker): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.worker_connections = self.cfg.worker_connections + self.max_keepalived = self.cfg.worker_connections - self.cfg.threads + # initialise the pool + self.tpool = None + self.poller = None + self._lock = None + self.futures = deque() + self._keep = deque() + self.nr_conns = 0 + + @classmethod + def check_config(cls, cfg, log): + max_keepalived = cfg.worker_connections - cfg.threads + + if max_keepalived <= 0 and cfg.keepalive: + log.warning("No keepalived connections can be handled. " + + "Check the number of worker connections and threads.") + + def init_process(self): + self.tpool = self.get_thread_pool() + self.poller = selectors.DefaultSelector() + self._lock = RLock() + super().init_process() + + def get_thread_pool(self): + """Override this method to customize how the thread pool is created""" + return futures.ThreadPoolExecutor(max_workers=self.cfg.threads) + + def handle_quit(self, sig, frame): + self.alive = False + # worker_int callback + self.cfg.worker_int(self) + self.tpool.shutdown(False) + time.sleep(0.1) + sys.exit(0) + + def _wrap_future(self, fs, conn): + fs.conn = conn + self.futures.append(fs) + fs.add_done_callback(self.finish_request) + + def enqueue_req(self, conn): + conn.init() + # submit the connection to a worker + fs = self.tpool.submit(self.handle, conn) + self._wrap_future(fs, conn) + + def accept(self, server, listener): + try: + sock, client = listener.accept() + # initialize the connection object + conn = TConn(self.cfg, sock, client, server) + self.nr_conns += 1 + # enqueue the job + self.enqueue_req(conn) + except EnvironmentError as e: + if e.errno not in (errno.EAGAIN, + errno.ECONNABORTED, errno.EWOULDBLOCK): + raise + + def reuse_connection(self, conn, client): + with self._lock: + # unregister the client from the poller + self.poller.unregister(client) + # remove the connection from keepalive + try: + self._keep.remove(conn) + except ValueError: + # race condition + return + + # submit the connection to a worker + self.enqueue_req(conn) + + def murder_keepalived(self): + now = time.time() + while True: + with self._lock: + try: + # remove the connection from the queue + conn = self._keep.popleft() + except IndexError: + break + + delta = conn.timeout - now + if delta > 0: + # add the connection back to the queue + with self._lock: + self._keep.appendleft(conn) + break + else: + self.nr_conns -= 1 + # remove the socket from the poller + with self._lock: + try: + self.poller.unregister(conn.sock) + except EnvironmentError as e: + if e.errno != errno.EBADF: + raise + except KeyError: + # already removed by the system, continue + pass + + # close the socket + conn.close() + + def is_parent_alive(self): + # If our parent changed then we shut down. + if self.ppid != os.getppid(): + self.log.info("Parent changed, shutting down: %s", self) + return False + return True + + def run(self): + # init listeners, add them to the event loop + for sock in self.sockets: + sock.setblocking(False) + # a race condition during graceful shutdown may make the listener + # name unavailable in the request handler so capture it once here + server = sock.getsockname() + acceptor = partial(self.accept, server) + self.poller.register(sock, selectors.EVENT_READ, acceptor) + + while self.alive: + # notify the arbiter we are alive + self.notify() + + # can we accept more connections? + if self.nr_conns < self.worker_connections: + # wait for an event + events = self.poller.select(1.0) + for key, _ in events: + callback = key.data + callback(key.fileobj) + + # check (but do not wait) for finished requests + result = futures.wait(self.futures, timeout=0, + return_when=futures.FIRST_COMPLETED) + else: + # wait for a request to finish + result = futures.wait(self.futures, timeout=1.0, + return_when=futures.FIRST_COMPLETED) + + # clean up finished requests + for fut in result.done: + self.futures.remove(fut) + + if not self.is_parent_alive(): + break + + # handle keepalive timeouts + self.murder_keepalived() + + self.tpool.shutdown(False) + self.poller.close() + + for s in self.sockets: + s.close() + + futures.wait(self.futures, timeout=self.cfg.graceful_timeout) + + def finish_request(self, fs): + if fs.cancelled(): + self.nr_conns -= 1 + fs.conn.close() + return + + try: + (keepalive, conn) = fs.result() + # if the connection should be kept alived add it + # to the eventloop and record it + if keepalive: + # flag the socket as non blocked + conn.sock.setblocking(False) + + # register the connection + conn.set_timeout() + with self._lock: + self._keep.append(conn) + + # add the socket to the event loop + self.poller.register(conn.sock, selectors.EVENT_READ, + partial(self.reuse_connection, conn)) + else: + self.nr_conns -= 1 + conn.close() + except: + # an exception happened, make sure to close the + # socket. + self.nr_conns -= 1 + fs.conn.close() + + def handle(self, conn): + keepalive = False + req = None + try: + req = next(conn.parser) + if not req: + return (False, conn) + + # handle the request + keepalive = self.handle_request(req, conn) + if keepalive: + return (keepalive, conn) + except http.errors.NoMoreData as e: + self.log.debug("Ignored premature client disconnection. %s", e) + + except StopIteration as e: + self.log.debug("Closing connection. %s", e) + except ssl.SSLError as e: + if e.args[0] == ssl.SSL_ERROR_EOF: + self.log.debug("ssl connection closed") + conn.sock.close() + else: + self.log.debug("Error processing SSL request.") + self.handle_error(req, conn.sock, conn.client, e) + + except EnvironmentError as e: + if e.errno not in (errno.EPIPE, errno.ECONNRESET): + self.log.exception("Socket error processing request.") + else: + if e.errno == errno.ECONNRESET: + self.log.debug("Ignoring connection reset") + else: + self.log.debug("Ignoring connection epipe") + except Exception as e: + self.handle_error(req, conn.sock, conn.client, e) + + return (False, conn) + + def handle_request(self, req, conn): + environ = {} + resp = None + try: + self.cfg.pre_request(self, req) + request_start = datetime.now() + resp, environ = wsgi.create(req, conn.sock, conn.client, + conn.server, self.cfg) + environ["wsgi.multithread"] = True + self.nr += 1 + if self.alive and self.nr >= self.max_requests: + self.log.info("Autorestarting worker after current request.") + resp.force_close() + self.alive = False + + if not self.cfg.keepalive: + resp.force_close() + elif len(self._keep) >= self.max_keepalived: + resp.force_close() + + respiter = self.wsgi(environ, resp.start_response) + try: + if isinstance(respiter, environ['wsgi.file_wrapper']): + resp.write_file(respiter) + else: + for item in respiter: + resp.write(item) + + resp.close() + request_time = datetime.now() - request_start + self.log.access(resp, req, environ, request_time) + finally: + if hasattr(respiter, "close"): + respiter.close() + + if resp.should_close(): + self.log.debug("Closing connection.") + return False + except EnvironmentError: + # pass to next try-except level + util.reraise(*sys.exc_info()) + except Exception: + if resp and resp.headers_sent: + # If the requests have already been sent, we should close the + # connection to indicate the error. + self.log.exception("Error handling request") + try: + conn.sock.shutdown(socket.SHUT_RDWR) + conn.sock.close() + except EnvironmentError: + pass + raise StopIteration() + raise + finally: + try: + self.cfg.post_request(self, req, environ, resp) + except Exception: + self.log.exception("Exception in post_request hook") + + return True diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gtornado.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gtornado.py new file mode 100644 index 0000000..c98acb8 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/gtornado.py @@ -0,0 +1,169 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import copy +import os +import sys + +try: + import tornado +except ImportError: + raise RuntimeError("You need tornado installed to use this worker.") +import tornado.web +import tornado.httpserver +from tornado.ioloop import IOLoop, PeriodicCallback +from tornado.wsgi import WSGIContainer +from gunicorn.workers.base import Worker +from gunicorn import __version__ as gversion + + +# Tornado 5.0 updated its IOLoop, and the `io_loop` arguments to many +# Tornado functions have been removed in Tornado 5.0. Also, they no +# longer store PeriodCallbacks in ioloop._callbacks. Instead we store +# them on our side, and use stop() on them when stopping the worker. +# See https://www.tornadoweb.org/en/stable/releases/v5.0.0.html#backwards-compatibility-notes +# for more details. +TORNADO5 = tornado.version_info >= (5, 0, 0) + + +class TornadoWorker(Worker): + + @classmethod + def setup(cls): + web = sys.modules.pop("tornado.web") + old_clear = web.RequestHandler.clear + + def clear(self): + old_clear(self) + if "Gunicorn" not in self._headers["Server"]: + self._headers["Server"] += " (Gunicorn/%s)" % gversion + web.RequestHandler.clear = clear + sys.modules["tornado.web"] = web + + def handle_exit(self, sig, frame): + if self.alive: + super().handle_exit(sig, frame) + + def handle_request(self): + self.nr += 1 + if self.alive and self.nr >= self.max_requests: + self.log.info("Autorestarting worker after current request.") + self.alive = False + + def watchdog(self): + if self.alive: + self.notify() + + if self.ppid != os.getppid(): + self.log.info("Parent changed, shutting down: %s", self) + self.alive = False + + def heartbeat(self): + if not self.alive: + if self.server_alive: + if hasattr(self, 'server'): + try: + self.server.stop() + except Exception: + pass + self.server_alive = False + else: + if TORNADO5: + for callback in self.callbacks: + callback.stop() + self.ioloop.stop() + else: + if not self.ioloop._callbacks: + self.ioloop.stop() + + def init_process(self): + # IOLoop cannot survive a fork or be shared across processes + # in any way. When multiple processes are being used, each process + # should create its own IOLoop. We should clear current IOLoop + # if exists before os.fork. + IOLoop.clear_current() + super().init_process() + + def run(self): + self.ioloop = IOLoop.instance() + self.alive = True + self.server_alive = False + + if TORNADO5: + self.callbacks = [] + self.callbacks.append(PeriodicCallback(self.watchdog, 1000)) + self.callbacks.append(PeriodicCallback(self.heartbeat, 1000)) + for callback in self.callbacks: + callback.start() + else: + PeriodicCallback(self.watchdog, 1000, io_loop=self.ioloop).start() + PeriodicCallback(self.heartbeat, 1000, io_loop=self.ioloop).start() + + # Assume the app is a WSGI callable if its not an + # instance of tornado.web.Application or is an + # instance of tornado.wsgi.WSGIApplication + app = self.wsgi + + if tornado.version_info[0] < 6: + if not isinstance(app, tornado.web.Application) or \ + isinstance(app, tornado.wsgi.WSGIApplication): + app = WSGIContainer(app) + + # Monkey-patching HTTPConnection.finish to count the + # number of requests being handled by Tornado. This + # will help gunicorn shutdown the worker if max_requests + # is exceeded. + httpserver = sys.modules["tornado.httpserver"] + if hasattr(httpserver, 'HTTPConnection'): + old_connection_finish = httpserver.HTTPConnection.finish + + def finish(other): + self.handle_request() + old_connection_finish(other) + httpserver.HTTPConnection.finish = finish + sys.modules["tornado.httpserver"] = httpserver + + server_class = tornado.httpserver.HTTPServer + else: + + class _HTTPServer(tornado.httpserver.HTTPServer): + + def on_close(instance, server_conn): + self.handle_request() + super(_HTTPServer, instance).on_close(server_conn) + + server_class = _HTTPServer + + if self.cfg.is_ssl: + _ssl_opt = copy.deepcopy(self.cfg.ssl_options) + # tornado refuses initialization if ssl_options contains following + # options + del _ssl_opt["do_handshake_on_connect"] + del _ssl_opt["suppress_ragged_eofs"] + if TORNADO5: + server = server_class(app, ssl_options=_ssl_opt) + else: + server = server_class(app, io_loop=self.ioloop, + ssl_options=_ssl_opt) + else: + if TORNADO5: + server = server_class(app) + else: + server = server_class(app, io_loop=self.ioloop) + + self.server = server + self.server_alive = True + + for s in self.sockets: + s.setblocking(0) + if hasattr(server, "add_socket"): # tornado > 2.0 + server.add_socket(s) + elif hasattr(server, "_sockets"): # tornado 2.0 + server._sockets[s.fileno()] = s + + server.no_keep_alive = self.cfg.keepalive <= 0 + server.start(num_processes=1) + + self.ioloop.start() diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/sync.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/sync.py new file mode 100644 index 0000000..ab9e085 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/sync.py @@ -0,0 +1,207 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. +# + +from datetime import datetime +import errno +import os +import select +import socket +import ssl +import sys + +import gunicorn.http as http +import gunicorn.http.wsgi as wsgi +import gunicorn.util as util +import gunicorn.workers.base as base + +class StopWaiting(Exception): + """ exception raised to stop waiting for a connection """ + +class SyncWorker(base.Worker): + + def accept(self, listener): + client, addr = listener.accept() + client.setblocking(1) + util.close_on_exec(client) + self.handle(listener, client, addr) + + def wait(self, timeout): + try: + self.notify() + ret = select.select(self.wait_fds, [], [], timeout) + if ret[0]: + if self.PIPE[0] in ret[0]: + os.read(self.PIPE[0], 1) + return ret[0] + + except select.error as e: + if e.args[0] == errno.EINTR: + return self.sockets + if e.args[0] == errno.EBADF: + if self.nr < 0: + return self.sockets + else: + raise StopWaiting + raise + + def is_parent_alive(self): + # If our parent changed then we shut down. + if self.ppid != os.getppid(): + self.log.info("Parent changed, shutting down: %s", self) + return False + return True + + def run_for_one(self, timeout): + listener = self.sockets[0] + while self.alive: + self.notify() + + # Accept a connection. If we get an error telling us + # that no connection is waiting we fall down to the + # select which is where we'll wait for a bit for new + # workers to come give us some love. + try: + self.accept(listener) + # Keep processing clients until no one is waiting. This + # prevents the need to select() for every client that we + # process. + continue + + except EnvironmentError as e: + if e.errno not in (errno.EAGAIN, errno.ECONNABORTED, + errno.EWOULDBLOCK): + raise + + if not self.is_parent_alive(): + return + + try: + self.wait(timeout) + except StopWaiting: + return + + def run_for_multiple(self, timeout): + while self.alive: + self.notify() + + try: + ready = self.wait(timeout) + except StopWaiting: + return + + if ready is not None: + for listener in ready: + if listener == self.PIPE[0]: + continue + + try: + self.accept(listener) + except EnvironmentError as e: + if e.errno not in (errno.EAGAIN, errno.ECONNABORTED, + errno.EWOULDBLOCK): + raise + + if not self.is_parent_alive(): + return + + def run(self): + # if no timeout is given the worker will never wait and will + # use the CPU for nothing. This minimal timeout prevent it. + timeout = self.timeout or 0.5 + + # self.socket appears to lose its blocking status after + # we fork in the arbiter. Reset it here. + for s in self.sockets: + s.setblocking(0) + + if len(self.sockets) > 1: + self.run_for_multiple(timeout) + else: + self.run_for_one(timeout) + + def handle(self, listener, client, addr): + req = None + try: + if self.cfg.is_ssl: + client = ssl.wrap_socket(client, server_side=True, + **self.cfg.ssl_options) + + parser = http.RequestParser(self.cfg, client) + req = next(parser) + self.handle_request(listener, req, client, addr) + except http.errors.NoMoreData as e: + self.log.debug("Ignored premature client disconnection. %s", e) + except StopIteration as e: + self.log.debug("Closing connection. %s", e) + except ssl.SSLError as e: + if e.args[0] == ssl.SSL_ERROR_EOF: + self.log.debug("ssl connection closed") + client.close() + else: + self.log.debug("Error processing SSL request.") + self.handle_error(req, client, addr, e) + except EnvironmentError as e: + if e.errno not in (errno.EPIPE, errno.ECONNRESET): + self.log.exception("Socket error processing request.") + else: + if e.errno == errno.ECONNRESET: + self.log.debug("Ignoring connection reset") + else: + self.log.debug("Ignoring EPIPE") + except Exception as e: + self.handle_error(req, client, addr, e) + finally: + util.close(client) + + def handle_request(self, listener, req, client, addr): + environ = {} + resp = None + try: + self.cfg.pre_request(self, req) + request_start = datetime.now() + resp, environ = wsgi.create(req, client, addr, + listener.getsockname(), self.cfg) + # Force the connection closed until someone shows + # a buffering proxy that supports Keep-Alive to + # the backend. + resp.force_close() + self.nr += 1 + if self.nr >= self.max_requests: + self.log.info("Autorestarting worker after current request.") + self.alive = False + respiter = self.wsgi(environ, resp.start_response) + try: + if isinstance(respiter, environ['wsgi.file_wrapper']): + resp.write_file(respiter) + else: + for item in respiter: + resp.write(item) + resp.close() + request_time = datetime.now() - request_start + self.log.access(resp, req, environ, request_time) + finally: + if hasattr(respiter, "close"): + respiter.close() + except EnvironmentError: + # pass to next try-except level + util.reraise(*sys.exc_info()) + except Exception: + if resp and resp.headers_sent: + # If the requests have already been sent, we should close the + # connection to indicate the error. + self.log.exception("Error handling request") + try: + client.shutdown(socket.SHUT_RDWR) + client.close() + except EnvironmentError: + pass + raise StopIteration() + raise + finally: + try: + self.cfg.post_request(self, req, environ, resp) + except Exception: + self.log.exception("Exception in post_request hook") diff --git a/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/workertmp.py b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/workertmp.py new file mode 100644 index 0000000..c475a12 --- /dev/null +++ b/parkingkonceptvenv/lib/python3.7/site-packages/gunicorn/workers/workertmp.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 - +# +# This file is part of gunicorn released under the MIT license. +# See the NOTICE for more information. + +import os +import platform +import tempfile + +from gunicorn import util + +PLATFORM = platform.system() +IS_CYGWIN = PLATFORM.startswith('CYGWIN') + + +class WorkerTmp(object): + + def __init__(self, cfg): + old_umask = os.umask(cfg.umask) + fdir = cfg.worker_tmp_dir + if fdir and not os.path.isdir(fdir): + raise RuntimeError("%s doesn't exist. Can't create workertmp." % fdir) + fd, name = tempfile.mkstemp(prefix="wgunicorn-", dir=fdir) + os.umask(old_umask) + + # change the owner and group of the file if the worker will run as + # a different user or group, so that the worker can modify the file + if cfg.uid != os.geteuid() or cfg.gid != os.getegid(): + util.chown(name, cfg.uid, cfg.gid) + + # unlink the file so we don't leak tempory files + try: + if not IS_CYGWIN: + util.unlink(name) + # In Python 3.8, open() emits RuntimeWarning if buffering=1 for binary mode. + # Because we never write to this file, pass 0 to switch buffering off. + self._tmp = os.fdopen(fd, 'w+b', 0) + except: + os.close(fd) + raise + + self.spinner = 0 + + def notify(self): + self.spinner = (self.spinner + 1) % 2 + os.fchmod(self._tmp.fileno(), self.spinner) + + def last_update(self): + return os.fstat(self._tmp.fileno()).st_ctime + + def fileno(self): + return self._tmp.fileno() + + def close(self): + return self._tmp.close() diff --git a/requirements.txt b/requirements.txt index 1a059e0..58cbedc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -7,6 +7,7 @@ Click==7.0 cycler==0.10.0 docutils==0.15.2 Flask==1.1.1 +gunicorn==20.0.0 idna==2.8 itsdangerous==1.1.0 Jinja2==2.10.3