def patch_thread(): try: from gevent import monkey import sys sys.modules.pop('threading', None) monkey.patch_thread() except: pass
def web_server_context(self, config): from gevent import monkey monkey.patch_thread() from infi.app_repo.webserver import start webserver = start(config) try: yield finally: webserver.close()
def web_server(config, signal_upstart): from gevent import monkey; monkey.patch_thread() from infi.app_repo.webserver import start webserver = start(config) if signal_upstart: from infi.app_repo.upstart import signal_init_that_i_am_ready signal_init_that_i_am_ready() webserver.serve_forever() webserver.close()
def web_server(config, signal_upstart): from gevent import monkey monkey.patch_thread() from infi.app_repo.webserver import start webserver = start(config) if signal_upstart: from infi.app_repo.upstart import signal_init_that_i_am_ready signal_init_that_i_am_ready() webserver.serve_forever() webserver.close()
def create_service_thread(serve_time=10): from gevent import monkey monkey.patch_socket() monkey.patch_thread() from threading import Thread from urb.service.urb_service import URBService create_config_manager() class ServiceThread(Thread): def run(self): self.urb_service = URBService(skip_cmd_line_config=True) self.urb_service.serve(serve_time) service_thread = ServiceThread() return service_thread
def init(): if gpy_runtime == 'gevent': # make gevent pre-available & stdlib patched import gevent from gevent import monkey # XXX workaround for gevent vs pypy2 crash. # XXX remove when gevent-1.4.1 is released (https://github.com/gevent/gevent/pull/1357). patch_thread = True if pypy and sys.version_info.major == 2: _ = monkey.patch_thread(existing_locks=False) assert _ in (True, None) patch_thread = False _ = monkey.patch_all(thread=patch_thread) # XXX sys=True ? if _ not in (True, None): # patched or nothing to do # XXX provide details raise RuntimeError('gevent monkey-patching failed') gpy_verextra = 'gevent %s' % gevent.__version__ elif gpy_runtime == 'threads': gpy_verextra = 'threads' else: raise RuntimeError('gpython: invalid runtime %s' % gpy_runtime) # put go, chan, select, ... into builtin namespace import golang from six.moves import builtins for k in golang.__all__: setattr(builtins, k, getattr(golang, k)) # sys.version sys.version += (' [GPython %s] [%s]' % (golang.__version__, gpy_verextra))
def test_thread(self): try: import thread except ImportError: import _thread as thread import threading from gevent import thread as gthread self.assertIs(thread.start_new_thread, gthread.start_new_thread) self.assertIs(threading._start_new_thread, gthread.start_new_thread) if sys.version_info[0] == 2: from gevent import threading as gthreading self.assertIs(threading._sleep, gthreading._sleep) self.assertFalse(monkey.is_object_patched('threading', 'Event')) monkey.patch_thread(Event=True) self.assertTrue(monkey.is_object_patched('threading', 'Event'))
def _start(self, db=None,reset=False): if not db: j.data.bcdb.db_start(self.instance, adminsecret=self.config.data["adminsecret_"], reset=reset) db = j.data.bcdb.get(self.instance) db.tables_get(self.app_dir) self.db = db # copy the templates in the local server dir for item in ["system"]: dest = j.sal.fs.joinPaths(self.code_generated_dir, "%s.py" % item) if reset or not j.sal.fs.exists(dest): src = j.sal.fs.joinPaths(j.servers.gedis._path, "templates", '%s.py' % item) j.sal.fs.copyFile(src, dest) # Generate models & populate self.schema_urls for namespace, table in db.tables.items(): # url = table.schema.url.replace(".","_") dest = j.sal.fs.joinPaths(self.code_generated_dir, "model_%s.py" % namespace) if reset or not j.sal.fs.exists(dest): code = j.servers.gedis.code_model_template.render(obj=table.schema) j.sal.fs.writeFile(dest, code) self.schema_urls.append(table.schema.url) # load commands if not loaded before if self._inited is False: self.init() self._sig_handler.append(gevent.signal(signal.SIGINT, self.stop)) from gevent import monkey monkey.patch_thread() import threading t = threading.Thread(target=self.websocket_server.serve_forever) t.setDaemon(True) t.start() self.logger.info("start Server on {0} - PORT: {1} - WEBSOCKETS PORT: {2}".format(self.host, self.port, self.websockets_port)) self.redis_server.serve_forever()
#!/usr/bin/env python import os import sys from gevent import monkey#; monkey.patch_all() monkey.patch_os() monkey.patch_time() monkey.patch_thread( _threading_local=False) monkey.patch_sys() monkey.patch_socket() monkey.patch_select() monkey.patch_ssl() monkey.patch_subprocess() from psycogreen.gevent import patch_psycopg; patch_psycopg(); if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "geventpooltest.settings") from django.core.management import execute_from_command_line execute_from_command_line(sys.argv)
""" Log classes : stdout, syslog and file loggers """ from gevent import monkey monkey.patch_all() import logging import logging.handlers from logging import RootLogger import sys import os from plivo.utils.encode import safe_str monkey.patch_thread() # thread must be patched after import LOG_DEBUG = logging.DEBUG LOG_ERROR = logging.ERROR LOG_INFO = logging.INFO LOG_WARN = logging.WARN LOG_WARNING = logging.WARNING LOG_CRITICAL = logging.CRITICAL LOG_FATAL = logging.FATAL LOG_NOTSET = logging.NOTSET __default_servicename__ = os.path.splitext(os.path.basename(sys.argv[0]))[0]
from gevent import socket as gevent_socket assert socket.create_connection is gevent_socket.create_connection import os import types for name in ('fork', 'forkpty'): if hasattr(os, name): attr = getattr(os, name) assert 'built-in' not in repr(attr), repr(attr) assert not isinstance(attr, types.BuiltinFunctionType), repr(attr) assert isinstance(attr, types.FunctionType), repr(attr) assert monkey.saved assert not monkey.is_object_patched('threading', 'Event') monkey.patch_thread(Event=True) assert monkey.is_object_patched('threading', 'Event') for modname in monkey.saved: assert monkey.is_module_patched(modname) for objname in monkey.saved[modname]: assert monkey.is_object_patched(modname, objname) orig_saved = {} for k, v in monkey.saved.items(): orig_saved[k] = v.copy() import warnings with warnings.catch_warnings(record=True) as issued_warnings: # Patch again, triggering two warnings, on for os=False/signal=True,
# @Author : Zhou Bo ([email protected]) # @Link : http://onlyus.online # @Version : $Id$ # from gevent.wsgi import WSGIServer # from SimpleXMLRPCServer import server # http_server = WSGIServer(('', 8800), server) # http_server.serve_forever() from socketserver import ThreadingMixIn from xmlrpc.server import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler from gevent import monkey #Threaded XML-RPC && Monkey Patch monkey.patch_socket() #Just 2 line! monkey.patch_thread() #Just 3 line! monkey.patch_select() #Just 3 line! class TXMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer): pass #Logic function def add(a, b): return a + b #Logic function 2 def gen(n): return "0" * n #create server server = TXMLRPCServer(('', 8000), SimpleXMLRPCRequestHandler) server.register_function(add, "add") server.register_function(gen, "gen")
$ ./test.py problem submission The modules will be tested individually. The module name needs to correspond to the test file name, that is, "problem" corresponds to "problem_test.py". This will take all files that include *_test.py and run them. ''' import unittest import sqlalchemy from sys import argv # Get a KeyError after custom tests without this. Full explanaition on SO # https://stackoverflow.com/questions/8774958/keyerror-in-module-threading-after-a-successful-py-test-run from gevent import monkey; monkey.patch_thread() import app import app.database as db # Switch the database session variable to point to the test database test_engine = sqlalchemy.create_engine( 'mysql+pymysql://root@localhost/acm_test?charset=utf8') test_conn = test_engine.connect() db.session = sqlalchemy.orm.Session(test_engine) if __name__ == "__main__": loader = unittest.defaultTestLoader if len(argv) > 1: print('Using custom tests')
def main(): monkey.patch_thread()
#!/usr/bin/env python # -*- coding: utf-8 -*- # # FileName: run.py # Author : summer1988 ([email protected]) # DateTime: 2015-11-12 17:31 # from gevent.monkey import patch_all, patch_socket, patch_thread, patch_time from pythunder.rpc.servers import FetcherServer # patch_all() patch_thread() patch_socket() patch_time() FetcherServer.serveForever()
def run(self, app, host=None, port=None, **kwargs): """Run the SocketIO web server. :param app: The Flask application instance. :param host: The hostname or IP address for the server to listen on. Defaults to 127.0.0.1. :param port: The port number for the server to listen on. Defaults to 5000. :param debug: ``True`` to start the server in debug mode, ``False`` to start in normal mode. :param use_reloader: ``True`` to enable the Flask reloader, ``False`` to disable it. :param extra_files: A list of additional files that the Flask reloader should watch. Defaults to ``None`` :param log_output: If ``True``, the server logs all incomming connections. If ``False`` logging is disabled. Defaults to ``True`` in debug mode, ``False`` in normal mode. Unused when the threading async mode is used. :param kwargs: Additional web server options. The web server options are specific to the server used in each of the supported async modes. Note that options provided here will not be seen when using an external web server such as gunicorn, since this method is not called in that case. """ if host is None: host = '127.0.0.1' if port is None: server_name = app.config['SERVER_NAME'] if server_name and ':' in server_name: port = int(server_name.rsplit(':', 1)[1]) else: port = 5000 debug = kwargs.pop('debug', app.debug) log_output = kwargs.pop('log_output', debug) use_reloader = kwargs.pop('use_reloader', debug) extra_files = kwargs.pop('extra_files', None) app.debug = debug if app.debug and self.server.eio.async_mode != 'threading': # put the debug middleware between the SocketIO middleware # and the Flask application instance # # mw1 mw2 mw3 Flask app # o ---- o ---- o ---- o # / # o Flask-SocketIO # \ middleware # o # Flask-SocketIO WebSocket handler # # BECOMES # # dbg-mw mw1 mw2 mw3 Flask app # o ---- o ---- o ---- o ---- o # / # o Flask-SocketIO # \ middleware # o # Flask-SocketIO WebSocket handler # self.sockio_mw.wsgi_app = DebuggedApplication( self.sockio_mw.wsgi_app, evalex=True) if self.server.eio.async_mode == 'threading': from werkzeug._internal import _log _log( 'warning', 'WebSocket transport not available. Install ' 'eventlet or gevent and gevent-websocket for ' 'improved performance.') app.run(host=host, port=port, threaded=True, use_reloader=use_reloader, **kwargs) elif self.server.eio.async_mode == 'eventlet': def run_server(): import eventlet import eventlet.wsgi import eventlet.green addresses = eventlet.green.socket.getaddrinfo(host, port) if not addresses: raise RuntimeError( 'Could not resolve host to a valid address') eventlet_socket = eventlet.listen(addresses[0][4], addresses[0][0]) # If provided an SSL argument, use an SSL socket ssl_args = [ 'keyfile', 'certfile', 'server_side', 'cert_reqs', 'ssl_version', 'ca_certs', 'do_handshake_on_connect', 'suppress_ragged_eofs', 'ciphers' ] ssl_params = {k: kwargs[k] for k in kwargs if k in ssl_args} if len(ssl_params) > 0: for k in ssl_params: kwargs.pop(k) ssl_params['server_side'] = True # Listening requires true eventlet_socket = eventlet.wrap_ssl( eventlet_socket, **ssl_params) eventlet.wsgi.server(eventlet_socket, app, log_output=log_output, **kwargs) if use_reloader: run_with_reloader(run_server, extra_files=extra_files) else: run_server() elif self.server.eio.async_mode == 'gevent': from gevent import pywsgi try: from geventwebsocket.handler import WebSocketHandler websocket = True except ImportError: app.logger.warning( 'WebSocket transport not available. Install ' 'gevent-websocket for improved performance.') websocket = False log = 'default' if not log_output: log = None if websocket: self.wsgi_server = pywsgi.WSGIServer( (host, port), app, handler_class=WebSocketHandler, log=log, **kwargs) else: self.wsgi_server = pywsgi.WSGIServer((host, port), app, log=log, **kwargs) if use_reloader: # monkey patching is required by the reloader from gevent import monkey monkey.patch_thread() monkey.patch_time() def run_server(): self.wsgi_server.serve_forever() run_with_reloader(run_server, extra_files=extra_files) else: self.wsgi_server.serve_forever()
import yaml import argparse import collections import datetime import setproctitle from cryptokit.base58 import get_bcaddress_version from collections import deque from gevent import Greenlet from gevent.monkey import patch_all, patch_thread from gevent.wsgi import WSGIServer from gevent.pool import Pool patch_all(thread=False) # Patch our threading events so we can use thread safe event with gevent patch_thread(threading=False, _threading_local=False, Event=True) import threading import logging from celery import Celery from pprint import pformat from .netmon import MonitorNetwork, monitor_nodes, MonitorAuxChain from .stratum_server import StratumServer from .agent_server import AgentServer from .stats import stat_rotater, StatManager from .monitor import monitor_app logger = logging.getLogger('manager') def monitor_runner(net_state, config, stratum_clients, server_state,
#! /usr/bin/python from gevent import monkey # monkey.patch_all() monkey.patch_socket() monkey.patch_ssl() monkey.patch_thread() monkey.patch_time() from JumpScale import j from JumpScale.tools import cmdutils from JumpScale.tools.alertservice import AlertService if __name__ == '__main__': parser = cmdutils.ArgumentParser() parser.add_argument('-c', '--clean', default=False, action='store_true') opts = parser.parse_args() j.application.start("alerts_server") j.logger.consolelogCategories.append('alerter') j.logger.consolelogCategories.append('rogerthat') j.logger.consolelogCategories.append('email') AlertService().start(opts) j.application.stop()
from typing import Any from gevent.monkey import patch_thread # type: ignore from doge.common.doge import Executer, Request, Response from doge.common.utils import import_string patch_thread() class BaseFilter(Executer): def __init__(self, context: Any, _next: Executer): self.next = _next def execute(self, req: Request) -> Response: return self.next.execute(req) class FilterChain: def __init__(self, context: Any): self.context = context def then(self, executer: Executer) -> Executer: filters = self.context.url.get_param("filters", []) for cls in reversed([import_string(f) for f in filters]): executer = cls(self.context, executer) return executer
""" Log classes : stdout, syslog and file loggers """ from gevent import monkey monkey.patch_all() import logging import logging.handlers from logging import RootLogger import sys import os from YouPBX.plivo.utils.encode import safe_str monkey.patch_thread() # thread must be patched after import LOG_DEBUG = logging.DEBUG LOG_ERROR = logging.ERROR LOG_INFO = logging.INFO LOG_WARN = logging.WARN LOG_WARNING = logging.WARNING LOG_CRITICAL = logging.CRITICAL LOG_FATAL = logging.FATAL LOG_NOTSET = logging.NOTSET __default_servicename__ = os.path.splitext(os.path.basename(sys.argv[0]))[0]
def setUp(self): # simulate standard app bootstrap from gevent import monkey; monkey.patch_thread() from ddtrace import tracer
def run_server(app, conf, host='127.0.0.1', port=5000, path=None, **kwargs): addr = path or (host, int(port)) if kwargs.pop('patch_thread', True): from gevent.monkey import patch_thread patch_thread() WSGIServer(addr, app, **kwargs).serve_forever()
import thread except ImportError: import _thread as thread import threading assert 'built-in' not in repr(thread.start_new_thread), repr( thread.start_new_thread) assert 'built-in' not in repr(threading._start_new_thread), repr( threading._start_new_thread) if sys.version_info[0] == 2: assert 'built-in' not in repr(threading._sleep), repr(threading._sleep) import socket from gevent import socket as gevent_socket assert socket.create_connection is gevent_socket.create_connection import os if hasattr(os, 'fork'): assert 'built-in' not in repr(os.fork), repr(os.fork) assert monkey.saved assert not monkey.is_object_patched('threading', 'Event') monkey.patch_thread(Event=True) assert monkey.is_object_patched('threading', 'Event') for modname in monkey.saved: assert monkey.is_module_patched(modname) for objname in monkey.saved[modname]: assert monkey.is_object_patched(modname, objname)
@app.error(404) @app.error(405) @app.error(500) @app.error(501) @app.error(502) @app.error(503) @view('errors') def our_err(err): return dict(e=err, ver=PROJECT_VERSION, date=str(datetime.now())[:-7]) @app.route('/static/<name:path>') def static_handler(name): return static_file(name, root='.') @app.route ('/full_stats') def stats(): projects = [i for i in Project.select().order_by(Project.create_time.desc())] tickets = [i for i in Ticket.select().order_by(Ticket.add_time.desc())] return template('stats.tpl', projects=projects, tickets=tickets, ver=PROJECT_VERSION, date=str(datetime.now())[:-7]); from gevent import monkey monkey.patch_os() monkey.patch_time() monkey.patch_thread(threading=False, _threading_local=False, Event=True, logging=True, existing_locks=True) monkey.patch_all(os=False, time=False, thread=False) app.run(host='0.0.0.0', port=8080, debug=True, reloader=False)
#!/usr/bin/env python PORT = 9000 import os os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' import django.core.handlers.wsgi application = django.core.handlers.wsgi.WSGIHandler() from socketio import SocketIOServer import psyco_gevent; psyco_gevent.make_psycopg_green() from gevent.monkey import patch_thread; patch_thread() if __name__ == '__main__': print 'Listening on port %s and on port 843 (flash policy server)' % PORT SocketIOServer(('', PORT), application, resource="socket.io").serve_forever()
from SocketServer import ThreadingMixIn from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler from gevent import monkey #Threaded XML-RPC && Monkey Patch monkey.patch_socket() #Just 2 line! monkey.patch_thread() #Just 3 line! monkey.patch_select() #Just 3 line! class TXMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer): pass #Logic function def add(a, b): return a + b #Logic function 2 def gen(n): return "0" * n #create server server = TXMLRPCServer(('', 8080), SimpleXMLRPCRequestHandler) server.register_function(add, "add") server.register_function(gen, "gen") server.serve_forever()
#this must be in the beginning so things are patched before ever imported by other libraries from gevent import monkey # monkey.patch_all() monkey.patch_socket() monkey.patch_thread() monkey.patch_time() import time from JumpScale import j import JumpScale.portal from JumpScale.baselib.cmdutils import argparse parser = argparse.ArgumentParser() parser.add_argument('-i', '--instance', help="Gridportal instance", required=True) opts = parser.parse_args() ays =j.atyourservice.get('jumpscale', 'portal', instance=opts.instance) j.application.instanceconfig = ays.hrd j.application.start("jumpscale:gridportal") j.application.initGrid() j.logger.disable() j.core.portal.getServer().start() j.application.stop()
def main(): # set UTF-8 as default encoding. # It is ok to import sys before gevent because sys is anyway always # imported first, e.g. to support sys.modules. import sys if sys.getdefaultencoding() != 'utf-8': reload(sys) sys.setdefaultencoding('utf-8') delattr(sys, 'setdefaultencoding') # safety check that we are not running from a setuptools entrypoint, where # it would be too late to monkey-patch stdlib. # # (os and signal are imported by python startup itself) # (on py3 _thread is imported by the interpreter early to support fine-grained import lock) avoid = [ 'pkg_resources', 'golang', 'socket', 'select', 'threading', 'thread', 'ssl', 'subprocess' ] # pypy7 made time always pre-imported (https://bitbucket.org/pypy/pypy/commits/6759b768) # cpython3.8 made time always pre-imported via zipimport hook: # https://github.com/python/cpython/commit/79d1c2e6c9d1 (`import time` in zipimport.py) pypy = ('PyPy' in sys.version) if (not pypy) and (sys.version_info < (3, 8)): avoid.append('time') bad = [] for mod in avoid: if mod in sys.modules: bad.append(mod) if bad: sysmodv = list(sys.modules.keys()) sysmodv.sort() raise RuntimeError( 'gpython: internal error: the following modules are pre-imported, but must be not:' '\n\n\t%s\n\nsys.modules:\n\n\t%s' % (bad, sysmodv)) # make gevent pre-available & stdlib patched import gevent from gevent import monkey # XXX workaround for gevent vs pypy2 crash. # XXX remove when gevent-1.4.1 is relased (https://github.com/gevent/gevent/pull/1357). patch_thread = True if pypy and sys.version_info.major == 2: _ = monkey.patch_thread(existing_locks=False) assert _ in (True, None) patch_thread = False _ = monkey.patch_all(thread=patch_thread) # XXX sys=True ? if _ not in (True, None): # patched or nothing to do # XXX provide details raise RuntimeError('gevent monkey-patching failed') # put go, chan, select, ... into builtin namespace import golang from six.moves import builtins for k in golang.__all__: setattr(builtins, k, getattr(golang, k)) # sys.executable & friends exe = sys.argv[0] # on windows there are # gpython-script.py # gpython.exe # gpython.manifest # and argv[0] is gpython-script.py if exe.endswith('-script.py'): exe = exe[:-len('-script.py')] exe = exe + '.exe' sys.executable = exe sys.version += (' [GPython %s] [gevent %s]' % (golang.__version__, gevent.__version__)) # tail to pymain pymain(sys.argv[1:])