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 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,
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:])
