由 Gevent SSL 引发的 XY Problem

# app.py
import requests
from flask import Flask
from flask import jsonify
app = Flask(__name__)


@app.route("/")
def hello():
    # import requests 这是一种解决方法
    resp = requests.get('https://httpbin.org/get')
    return jsonify(resp.json())

# run.py
from gunicorn.app.base import BaseApplication
from app import app


class StandaloneApplication(BaseApplication):

    def __init__(self, app, options=None):
        self.options = options or {}
        self.application = app
        super().__init__()

    def load_config(self):
        config = {key: value for key, value in self.options.items()
                  if key in self.cfg.settings and value is not None}
        for key, value in config.items():
            self.cfg.set(key.lower(), value)

    def load(self):
        return self.application


if __name__ == '__main__':
    options = {
        'bind': '%s:%s' % ('127.0.0.1', '8000'),
        'workers': 2,
        'worker_class': 'gevent'
    }
    StandaloneApplication(app, options).run()

# https://github.com/benoitc/gunicorn/blob/29f0394cdd381df176a3df3c25bb3fdd2486a173/gunicorn/workers/ggevent.py#L57
    def patch(self):
        from gevent import monkey
        monkey.noisy = False

        # if the new version is used make sure to patch subprocess
        if gevent.version_info[0] == 0:
            monkey.patch_all()
        else:
            monkey.patch_all(subprocess=True)

import ssl
from ssl import SSLContext

from gevent import monkey
monkey.patch_all()

context = SSLContext(ssl.PROTOCOL_SSLv23)
context.options |= 0  # Boom

import ssl

from gevent import monkey
monkey.patch_all()

context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.options |= 0  # Ok

import ssl

from gevent import monkey
monkey.patch_all()

from ssl import SSLContext

context = SSLContext(ssl.PROTOCOL_SSLv23)
context.options |= 0  # Ok

# https://github.com/python/cpython/blob/9a3ffc0492d1310ead9ce8f5ee678c26b20a338d/Lib/ssl.py#L505
class SSLContext(_SSLContext):
    @options.setter
    def options(self, value):
        super(SSLContext, SSLContext).options.__set__(self, value)

@options.setter
def options(self, value):
	print(SSLContext.__module__)
	context = super(SSLContext, SSLContext)
	print(context.__module__)
    context.options.__set__(self, value)

def create_app():
    app = Flask(__name__.split('.')[0], template_folder=Config.TEMPLATE_FOLDER)
    app.config.from_object(Config)
    register_extensions(app)
    register_blueprints(app)
    register_schedulers(app)
    return app

StandaloneApplication(create_app(), options).run()

def register_schedulers(app: Flask):
    """ Register schedulers. """
    cron = BlockingScheduler(config={
        'timezone': app.config['TIMEZONE']
    })
    now = datetime.datetime.now(tz=app.config['TIMEZONE'])
    cron.add_job(
        cron1,
        args=[app],
        trigger=IntervalTrigger(seconds=60 * 60 * 24)
    )
    def start():
        try:
            cron.start()
        except KeyboardInterrupt:
            cron.shutdown()
            sys.exit(0)

    Process(target=start, daemon=True).start()

# https://github.com/python/cpython/blob/9a3ffc0492d1310ead9ce8f5ee678c26b20a338d/Lib/multiprocessing/util.py#L327
def _exit_function(info=info, debug=debug, _run_finalizers=_run_finalizers,
                   active_children=process.active_children,
                   current_process=process.current_process):
    # We hold on to references to functions in the arglist due to the
    # situation described below, where this function is called after this
    # module's globals are destroyed.

    global _exiting

    if not _exiting:
        _exiting = True

        info('process shutting down')
        debug('running all "atexit" finalizers with priority >= 0')
        _run_finalizers(0)

        if current_process() is not None:
            # We check if the current process is None here because if
            # it's None, any call to ``active_children()`` will raise
            # an AttributeError (active_children winds up trying to
            # get attributes from util._current_process).  One
            # situation where this can happen is if someone has
            # manipulated sys.modules, causing this module to be
            # garbage collected.  The destructor for the module type
            # then replaces all values in the module dict with None.
            # For instance, after setuptools runs a test it replaces
            # sys.modules with a copy created earlier.  See issues
            # #9775 and #15881.  Also related: #4106, #9205, and
            # #9207.

            for p in active_children():
                if p.daemon:
                    info('calling terminate() for daemon %s', p.name)
                    p._popen.terminate()

            for p in active_children():
                info('calling join() for process %s', p.name)
                p.join()

        debug('running the remaining "atexit" finalizers')
        _run_finalizers()

atexit.register(_exit_function)

# https://github.com/python/cpython/blob/9a3ffc0492d1310ead9ce8f5ee678c26b20a338d/Lib/multiprocessing/process.py#L133
class BaseProcess(object):
    def join(self, timeout=None):
        '''
        Wait until child process terminates
        '''
        self._check_closed()
        assert self._parent_pid == os.getpid(), 'can only join a child process'
        assert self._popen is not None, 'can only join a started process'
        res = self._popen.wait(timeout)
        if res is not None:
            _children.discard(self)

def post_worker_init(worker):
    for child in multiprocessing.process.active_children():
        if child.name == 'xxx':
            multiprocessing.process._children.remove(child)