def run(app, host=None, port=None, debug=None, logger=logger):
monkey.patch_all()
address = get_address(host, port, app.config['SERVER_NAME'])
if debug is not None:
app.debug = debug
if app.debug:
#app.wsgi_app = DebuggedApplication(app.wsgi_app, evalex=True)
server = WebSocketServer(address, app.wsgi_app, debug=debug)
server._logger = logger
logger.setLevel(logging.INFO)
def run_server():
server.serve_forever()
if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
server.logger.info(' * Running on http://%s:%d/' % address)
server.logger.info(' * WebSocket enabled')
run_with_reloader(run_server)
else:
server = WebSocketServer(address, app.wsgi_app, debug=debug)
server._logger = logger
server.serve_forever()
return server
def run(config):
import atexit
import sys
# Reset sys.modules so that g-event can re-monkeypatch.
# This is needed because distribute's pkg_resources imports urllib & co, before we can properly monkey patch it. ;(
modules_to_reset = {'urllib', 'socket', '_ssl', 'ssl', 'select', 'thread',
'threading', 'time', 'os', 'subprocess'}
for k in list(sys.modules.keys()):
if k.startswith('dissonance.') or k in modules_to_reset:
del sys.modules[k]
from gevent.monkey import patch_all
patch_all()
from .dissonance import Dissonance
import logging
logging.basicConfig(**getattr(config, 'logging', {}))
j = Dissonance(config)
try:
j.run()
atexit.register(j.stop)
j.join()
except KeyboardInterrupt:
print("Got ^C. Stopping!")
def monkey_patch_gevent():
"""Monkey-patch gevent into core and zmq."""
try:
from gevent import monkey
except ImportError:
return
monkey.patch_all()
try:
import zmq
import zmq.eventloop
import zmq.eventloop.ioloop
import zmq.eventloop.zmqstream
import zmq.green
import zmq.green.eventloop
import zmq.green.eventloop.ioloop
import zmq.green.eventloop.zmqstream
except ImportError:
return
TO_PATCH = ((zmq, zmq.green),
(zmq.eventloop, zmq.green.eventloop),
(zmq.eventloop.ioloop, zmq.green.eventloop.ioloop),
(zmq.eventloop.zmqstream, zmq.green.eventloop.zmqstream))
for (red, green) in TO_PATCH:
for name in dir(red):
redval = getattr(red, name)
if name.startswith('__') or type(redval) is type(zmq):
continue
try:
greenval = getattr(green, name)
except AttributeError:
continue
if redval is not greenval:
setattr(red, name, greenval)
def handle(self, *args, **options):
if not options['noinput']:
confirm = raw_input("""
### %s Fast Reindex !!! ###
You have requested to do a fluff index reset via fast track.
This will update all your fluff indicators in place.
Type 'yes' to continue, or 'no' to cancel: """ % self.pillow_class.__name__)
if confirm != 'yes':
print "\tReset cancelled."
return
from gevent.monkey import patch_all
patch_all()
self._bootstrap(options)
start = datetime.utcnow()
gevent.signal(signal.SIGQUIT, gevent.shutdown)
queue = Queue(POOL_SIZE)
workers = [gevent.spawn(worker, self, queue) for i in range(POOL_SIZE)]
print "Starting fast tracked reindexing"
for i, row in enumerate(self.full_couch_view_iter()):
queue.put((row, i))
gevent.joinall(workers)
end = datetime.utcnow()
print "done in %s seconds" % (end - start).seconds
def _open(self, scheme='mongodb://'):
hostname, dbname, options = self._parse_uri(scheme=scheme)
conf = self._prepare_client_options(options)
conf['host'] = hostname
env = _detect_environment()
if env == 'gevent':
from gevent import monkey
monkey.patch_all()
elif env == 'eventlet':
from eventlet import monkey_patch
monkey_patch()
mongoconn = MongoClient(**conf)
database = mongoconn[dbname]
version = mongoconn.server_info()['version']
if tuple(map(int, version.split('.')[:2])) < (1, 3):
raise NotImplementedError(
'Kombu requires MongoDB version 1.3+ (server is {0})'.format(
version))
self._create_broadcast(database, options)
self._client = database
def server(host=RESTAPI_DEFAULT_ADDRESS, port=RESTAPI_DEFAULT_PORT, adapter=RESTAPI_DEFAULT_ADAPTER):
"""
REST-JSON API server
"""
DataStore.admin_id = hexencode(os.urandom(16))
Database.filepath = tempfile.mkstemp(prefix="sqlmapipc-", text=False)[1]
#make adminid to known this is safe because api only avalible to local
file_object = open('/www/xseclab.com/termite/.sqlmapadminid', 'w')
file_object.write(DataStore.admin_id)
file_object.close( )
logger.info("Running REST-JSON API server at '%s:%d'.." % (host, port))
logger.info("Admin ID: %s" % DataStore.admin_id)
logger.debug("IPC database: %s" % Database.filepath)
# Initialize IPC database
DataStore.current_db = Database()
DataStore.current_db.connect()
DataStore.current_db.init()
# Run RESTful API
try:
if adapter == "gevent":
from gevent import monkey
monkey.patch_all()
elif adapter == "eventlet":
import eventlet
eventlet.monkey_patch()
logger.debug("Using adapter '%s' to run bottle" % adapter)
run(host=host, port=port, quiet=True, debug=False, server=adapter)
except socket.error, ex:
if "already in use" in getSafeExString(ex):
logger.error("Address already in use ('%s:%s')" % (host, port))
else:
raise
def search_index_service(db):
# Based on the syncback_service fixture in tests/util/base.
monkey.patch_all(aggressive=False)
from inbox.transactions.search import SearchIndexService
s = SearchIndexService(poll_interval=0.1)
s.start()
yield s
def setup(cls):
from gevent import monkey
monkey.noisy = False
monkey.patch_all()
# monkey patch sendfile to make it none blocking
patch_sendfile()
def run_server(instance_dir, address, port, access_log=False):
# workaround on osx, disable kqueue
if sys.platform == "darwin":
os.environ['EVENT_NOKQUEUE'] = "1"
sys.path.insert(0, instance_dir)
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
# This application object is used by any WSGI server configured to use this
# file. This includes Django's development server, if the WSGI_APPLICATION
# setting points here.
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
from gevent import monkey
monkey.patch_all(dns=False)
from gevent.pywsgi import WSGIServer
if access_log:
logfile = 'default'
else:
logfile = file(os.devnull, 'a+')
server = WSGIServer((address, port), application, log=logfile)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def basic(topic="topic", channel="channel", count=1e6, size=10, gevent=False, max_in_flight=2500, profile=False):
"""Basic benchmark"""
if gevent:
from gevent import monkey
monkey.patch_all()
# Check the types of the arguments
count = int(count)
size = int(size)
max_in_flight = int(max_in_flight)
from nsq.http import nsqd
from nsq.reader import Reader
print "Publishing messages..."
for batch in grouper(messages(count, size), 1000):
nsqd.Client("http://localhost:4151").mpub(topic, batch)
print "Consuming messages"
client = Reader(topic, channel, nsqd_tcp_addresses=["localhost:4150"], max_in_flight=max_in_flight)
with closing(client):
start = -time.time()
if profile:
with profiler():
for message in islice(client, count):
message.fin()
else:
for message in islice(client, count):
message.fin()
start += time.time()
print "Finished %i messages in %fs (%5.2f messages / second)" % (count, start, count / start)
def _open(self, scheme='mongodb://'):
hostname, dbname, options = self._parse_uri(scheme=scheme)
conf = self._prepare_client_options(options)
conf['host'] = hostname
env = _detect_environment()
if env == 'gevent':
from gevent import monkey
monkey.patch_all()
elif env == 'eventlet':
from eventlet import monkey_patch
monkey_patch()
mongoconn = MongoClient(**conf)
database = mongoconn[dbname]
version_str = mongoconn.server_info()['version']
version = tuple(map(int, version_str.split('.')))
if version < (1, 3):
raise VersionMismatch(E_SERVER_VERSION.format(version_str))
elif self.ttl and version < (2, 2):
raise VersionMismatch(E_NO_TTL_INDEXES.format(version_str))
return database
def gevent_run(app, port=5000, log=None, error_log=None, address='',
monkey_patch=True, start=True, **kwargs): # pragma: no cover
"""Run your app in gevent.wsgi.WSGIServer
:param app: wsgi application, ex. Microservice instance
:param port: int, listen port, default 5000
:param address: str, listen address, default: ""
:param log: logger instance, default app.logger
:param error_log: logger instance, default app.logger
:param monkey_patch: boolean, use gevent.monkey.patch_all() for patching standard modules, default: True
:param start: boolean, if True, server will be start (server.serve_forever())
:param kwargs: other params for WSGIServer(**kwargs)
:return: server
"""
if log is None:
log = app.logger
if error_log is None:
error_log = app.logger
if monkey_patch:
from gevent import monkey
monkey.patch_all()
from gevent.wsgi import WSGIServer
http_server = WSGIServer((address, port), app, log=log, error_log=error_log,
**kwargs)
if start:
http_server.serve_forever()
return http_server
def main():
parser = get_parser()
options, _ = parser.parse_args()
if options.GEVENT:
from seismograph.utils import pyv
pyv.check_gevent_supported()
from gevent.monkey import patch_all
patch_all(thread=False)
from seismograph.ext.mocker import SERVER_TYPES
try:
mock_server_class = SERVER_TYPES[options.SERVER_TYPE]
except KeyError:
raise ValueError('Incorrect server type')
server = mock_server_class(
options.MOCKS_DIR,
host=options.HOST,
port=options.PORT,
debug=options.NO_DEBUG,
gevent=options.GEVENT,
threading=options.THREADING,
multiprocessing=options.MULTIPROCESSING,
)
server.serve_forever()
def patch_all(gevent=True, pdb=True, **kwargs):
if gevent:
patch_gevent()
if pdb:
patch_pdb()
from gevent.monkey import patch_all
patch_all(**kwargs)
def taskIncStats(stats):
print "taskIncStats(stats)"
GEVENT_MONKEY_PATCH = settings.TILEJET_GEVENT_MONKEY_PATCH
#=======#
now = datetime.datetime.now()
if GEVENT_MONKEY_PATCH:
# Import Gevent and monkey patch
from gevent import monkey
monkey.patch_all()
# Update MongoDB
from pymongo import MongoClient
client = None
db = None
try:
client = MongoClient(settings.TILEJET_DBHOST, settings.TILEJET_DBPORT)
db = client[settings.TILEJET_DBNAME]
except:
client = None
db = None
errorline = "Error: Could not connet to stats database from taskIncStats. Most likely issue with connection pool"
error_file = settings.LOG_ERRORS_ROOT+os.sep+"requests_tiles_"+now.strftime('%Y-%m-%d')+"_errors.txt"
with open(error_file,'a') as f:
f.write(errorline+"\n")
# Increment Statistics
if client and db:
for stat in stats:
try:
collection = db[stat['collection']]
collection.update(stat['attributes'], {'$set': stat['attributes'], '$inc': {'value': 1}}, upsert=True, w=0)
except:
errorline = "Error: Could not connect to upsert stats from taskIncStats. Most likely issue with sockets"
error_file = settings.LOG_ERRORS_ROOT+os.sep+"requests_tiles_"+now.strftime('%Y-%m-%d')+"_errors.txt"
with open(error_file,'a') as f:
f.write(errorline+"\n")
def gevent(app, address, **options):
from gevent import monkey
monkey.patch_all()
from gevent import pywsgi
from gevent.pool import Pool
pywsgi.WSGIServer(address, app, spawn='workers' in options and Pool(
int(options.workers)) or 'default').serve_forever()
def taskIncStats(stats):
now = datetime.datetime.now()
# Import Gevent and monkey patch
from gevent import monkey
monkey.patch_all()
# Update MongoDB
from pymongo import MongoClient
client = None
db = None
try:
#client = MongoClient('localhost', 27017)
client = MongoClient('/tmp/mongodb-27017.sock')
db = client.ittc
except:
client = None
db = None
errorline = "Error: Could not connet to stats database from taskIncStats. Most likely issue with connection pool"
error_file = settings.LOG_ERRORS_ROOT+os.sep+"requests_tiles_"+now.strftime('%Y-%m-%d')+"_errors.txt"
with open(error_file,'a') as f:
f.write(errorline+"\n")
# Increment Statistics
if client and db:
for stat in stats:
try:
collection = db[stat['collection']]
collection.update(stat['attributes'], {'$set': stat['attributes'], '$inc': {'value': 1}}, upsert=True, w=0)
except:
errorline = "Error: Could not connect to upsert stats from taskIncStats. Most likely issue with sockets"
error_file = settings.LOG_ERRORS_ROOT+os.sep+"requests_tiles_"+now.strftime('%Y-%m-%d')+"_errors.txt"
with open(error_file,'a') as f:
f.write(errorline+"\n")
def run_app(app_path, **kwargs):
"""
Command for run application.
:usage:
noseapp-manage run import.path.to:get_app_function
:app_path: path for importing application
:kwargs: kwargs of create application function
"""
for argv in sys.argv:
if 'gevent' in argv:
if pyv.IS_PYTHON_3:
raise pyv.UnSupportedError('gevent lib unsupported with python 3')
try:
from gevent.monkey import patch_all
patch_all()
except ImportError as e:
raise ImportError(
'{}. {}.'.format(e.message, 'Please install gevent'),
)
break
app = funcs.get_create_app_func(app_path)(**kwargs)
app.run()
def run(app, host, port):
print_banner()
monkey.patch_all()
server = setup_server(app, host, port)
server.serve_forever()
def server(args):
# import gevent and monkey patch here so only the gevent server is
# affected.
from gevent import monkey
monkey.patch_all()
config.OPTIONS['debug'] = args.debug
bottle.run(app=webapp.app(), server='gevent', debug=args.debug)
def main():
from gevent import monkey; monkey.patch_all()
from .orchestra import monkey; monkey.patch_all()
import logging
log = logging.getLogger(__name__)
ctx = parse_args()
loglevel = logging.INFO
if ctx.verbose:
loglevel = logging.DEBUG
logging.basicConfig(
level=loglevel,
)
from teuthology.misc import read_config
read_config(ctx)
log.info('\n '.join(['targets:', ] + yaml.safe_dump(ctx.config['targets'], default_flow_style=False).splitlines()))
if ctx.owner is None:
from teuthology.misc import get_user
ctx.owner = get_user()
nuke(ctx, log, ctx.unlock, ctx.synch_clocks, ctx.reboot_all)
def main(argv):
"""
Точка входа в приложение.
В случае возникновения ошибки в приложении, оно засыпает на config.SLEEP_ON_FAIL секунд.
:param argv: агрументы командной строки.
:type argv: list
"""
args = utils.parse_cmd_args(argv[1:])
config = utils.prepare(args)
dictConfig(config.LOGGING)
current_thread().name = 'pusher.main'
install_signal_handlers()
patch_all()
while run_application:
try:
main_loop(config)
except Exception as exc:
logger.error(
'Error in main loop. Go to sleep on {} second(s).'.format(config.SLEEP_ON_FAIL)
)
logger.exception(exc)
sleep(config.SLEEP_ON_FAIL)
else:
logger.info('Stop application loop in main.')
return exit_code
def main():
monkey.patch_all()
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--project_list', default=None, required=False)
parser.add_argument('-n', '--num_tasks', default=1, required=False)
parser.add_argument('-k', '--asana_api_key', default=ASANA_API_KEY)
parser.add_argument('-w', '--workspace', default=None, required=False)
args = parser.parse_args()
asana_api = asana.AsanaAPI(debug=True)
# collect tasks from project
universal_result_list = list()
if project_list == None:
project_list = [project['id'] for project in asana_api.list_projects(include_archived=False)]
else:
pass
pool = Pool(MAX_GREENLETS)
[pool.spawn(get_asana_project, asana_api, project_id, num_projects) for project_id in project_list]
pool.join()
# select task, url at random from each project
# remove the parent map rows first!
selected_tasks = []
def main():
formatter = logging.Formatter(
'[%(asctime)s] %(name)s<%(levelname)s> %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
args = get_parser().parse_args()
if args.subworker and args.worker != 'process':
logger.error('using subworkers requires worker set to be "process"')
return
if args.worker == 'thread':
from concurrent.futures import ThreadPoolExecutor
e = ThreadPoolExecutor(args.concurrency)
for _ in range(args.concurrency):
e.submit(run_worker, args.odq, args.queue, args.worker)
elif args.worker == 'process':
from concurrent.futures import ProcessPoolExecutor
e = ProcessPoolExecutor(args.concurrency)
for _ in range(args.concurrency):
e.submit(run_worker, args.odq, args.queue, args.worker,
args.subworker, args.subconcurrency)
elif args.worker == 'gevent':
from gevent import monkey
monkey.patch_all()
from gevent.pool import Pool
pool = Pool(args.concurrency)
for _ in range(args.concurrency):
pool.spawn(run_worker, args.odq, args.queue, args.worker)
pool.join()
def target():
tcurrent = threading.current_thread()
monkey.patch_all()
tcurrent2 = threading.current_thread()
self.assertIsNot(tcurrent, current)
# We get a dummy thread now
self.assertIsNot(tcurrent, tcurrent2)
def test():
scheduler = BaseScheduler()
def add_new_task(task):
scheduler.add_new_task(task)
import sys
if 'threading' in sys.modules:
del sys.modules['threading']
from gevent import monkey
monkey.patch_all()
from gevent.pool import Pool
gp = Pool(100)
import time
st = time.time()
tasks = []
for i in xrange(1, 1000):
t = {
'uuid': i
}
tasks.append(t)
gp.spawn(add_new_task, tasks)
gp.join()
end = time.time()
tmp = list(iter(scheduler.new_tasks_generator()))
cnt = len(tmp)
while tmp:
#for i in xrange(1000):
tmp = list(iter(scheduler.new_tasks_generator()))
cnt += len(tmp)
print [ i in scheduler.rfilter for i in xrange(1, 1000) ]
def test_3(self):
'''Submit to job queue with gevent.'''
monkey.patch_all()
gm_client = gearman.GearmanClient([self.gm_server])
for _ in range(self.jobs):
gm_client.submit_job("with_gevent",self.data,background=True)
def commit_to_cache(cache_location, cache_params, key, obj, GEVENT_MONKEY_PATCH=False):
if GEVENT_MONKEY_PATCH:
# Import Gevent and monkey patch
try:
from gevent import monkey
monkey.patch_all()
except:
print "gevent monkey patch failed"
# Import Django Cache (mozilla/django-memcached-pool)
#from django.core.cache import cache, caches, get_cache
#from django.core.cache import caches
# Get Tile Cache
cache = None
success = False
try:
from umemcache import MemcachedError
from memcachepool.cache import UMemcacheCache
cache = UMemcacheCache(cache_location, cache_params)
#cache = caches['tiles']
except:
cache = None
if cache:
try:
cache.set(key, obj)
success = True
except MemcachedError, e:
print e
success = False
def get_from_cache(cache_location, cache_params, name, key, GEVENT_MONKEY_PATCH=False):
if GEVENT_MONKEY_PATCH:
# Import Gevent and monkey patch
try:
from gevent import monkey
monkey.patch_all()
except:
print "gevent monkey patch failed"
# Import Django Cache (mozilla/django-memcached-pool)
#from django.core.cache import cache, caches, get_cache
#from django.core.cache import caches
# Get Tile Cache
cache = None
item = None
try:
from umemcache import MemcachedError
from memcachepool.cache import UMemcacheCache
cache = UMemcacheCache(cache_location, cache_params)
#cache = caches['tiles']
except:
cache = None
if cache:
try:
item = cache.get(key)
except socket_error, e:
print e
item = None
except MemcachedError, e:
print e
item = None
def greenlet(self):
'''Run an asis server in a greenlet.'''
# Ensure that monkey-patching has happened before running the server.
# We avoid aggressively monkey-patching at the top of the file since
# this class may be used from many contexts, including potentially
# without the advent of `gevent`.
from gevent import monkey
monkey.patch_all()
import gevent
spawned = gevent.Greenlet.spawn(self.run)
try:
# Wait until something is listening on the specified port. Two
# outcomes are possible -- an exception happens and the greenlet
# terminates, or it starts the server and is listening on the
# provided port.
while spawned:
if self.check_ready():
break
# If the greenlet had an exception, re-raise it in this context
if not spawned:
raise spawned.exception
yield spawned
finally:
spawned.kill(KeyboardInterrupt, block=True)
spawned.join()
This module contains an asynchronous replica of ``requests.api``, powered
by gevent. All API methods return a ``Request`` instance (as opposed to
``Response``). A list of requests can be sent with ``map()``.
"""
from functools import partial
import traceback
try:
import gevent
from gevent import monkey as curious_george
from gevent.pool import Pool
except ImportError:
raise RuntimeError('Gevent is required for grequests.')
# Monkey-patch.
curious_george.patch_all(thread=False, select=False)
from requests import Session
__all__ = ('map', 'imap', 'get', 'options', 'head', 'post', 'put', 'patch',
'delete', 'request')
class AsyncRequest(object):
""" Asynchronous request.
Accept same parameters as ``Session.request`` and some additional:
:param session: Session which will do request
:param callback: Callback called on response.
Same as passing ``hooks={'response': callback}``
from __future__ import unicode_literals
import re
import os
import sys
import json
import glob
import random
import gevent
import logging
from gevent.pool import Pool
from gevent.monkey import patch_all
from redis import StrictRedis
from importlib import import_module
from slackclient import SlackClient
from settings import APPS, BOT_NAME, ICON_URL, SLACK_TOKEN, REDIS_URL
patch_all()
pool = Pool(20)
CMD_PREFIX = ''
logger = logging.getLogger()
class RedisBrain(object):
def __init__(self):
try:
self.redis = StrictRedis(host=REDIS_URL)
except Exception as e:
logger.error(e)
self.redis = None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 通过urllib(2)模块下载网络内容
import urllib, urllib2, gevent
# 引入正则表达式模块，时间模块
import re, time
from gevent import monkey
monkey.patch_all()
def geturllist(url):
url_list = []
print
url
s = urllib2.urlopen(url)
text = s.read()
# 正则匹配，匹配其中的图片
html = re.search(r'<ol.*</ol>', text, re.S)
urls = re.finditer(r'<p><img src="(.+?)jpg" /></p>', html.group(), re.I)
for i in urls:
url = i.group(1).strip() + str("jpg")
url_list.append(url)
return url_list
def download(down_url):
name = str(time.time())[:-3] + "_" + re.sub('.+?/', '', down_url)
print
name
urllib.urlretrieve(down_url, "D:\\TEMP\\" + name)
def __init__(self,
oag,
initurl=None,
rpc_enabled=True,
rpc_acl_policy=ACL.LOCAL_ALL,
rpc_async=True,
rpc_dbupdate_listen=False,
heartbeat_enabled=True):
### Store reference to OAG
self._oag = weakref.ref(oag)
# Greenlets spawned by RPC
self._glets = []
### Spin up rpc infrastructure
# Imports
from gevent import spawn, monkey
from gevent.lock import BoundedSemaphore
# Is RPC initialization complete?
self._rpc_init_done = False
# A very basic question...
self._rpc_enabled = rpc_enabled
# Who's allowed to access this node?
self._rpc_acl_policy = rpc_acl_policy
# Serialize access to RPC
self._rpcsem = BoundedSemaphore(1)
# Routes all incoming RPC requests (dead to start with)
self._rpcrtr = None
# Registrations received from other OAGs
self._rpcreqs = {}
# Async
self._rpc_async = rpc_async
# Holding spot for RPC discoverability - default off
self._rpc_discovery = None
# Listen for dbupdates elsewhere
self._rpc_dbupdate_listen = rpc_dbupdate_listen
# Should you heartbeat?
self._rpc_heartbeat = heartbeat_enabled
# Invalidation cache
self._rpc_transaction = RpcTransaction(self)
# Stoplist of OAG streams that shouldn't be exposed over RPC
self._rpc_stop_list = [
'cache',
'db',
'discoverable',
'logger',
'propmgr',
'rdf',
'rpc',
] + [attr for attr in dir(self._oag) if attr[0] == '_']
### Set up OAG proxying infrastructure
# Are we proxying for another OAG?
self._proxy_mode = False
# OAG URL this one is proxying
self._proxy_url = initurl
# List of props we are making RPC calls for
self._proxy_oags = []
### Carry out ininitialization
# Is this OAG RPC enabled? If no, don't proceed
if not self._rpc_enabled:
return
# RPC routing
if not self._rpc_init_done:
monkey.patch_all()
with self._rpcsem:
self._rpcrtr = OAGRPC_RTR_Requests(self._oag)
self._rpcrtr.start()
if self._rpc_async:
# Force execution of newly spawned greenlets
g = spawn(self.start)
g.name = "%s/%s" % (str(self._rpcrtr.id), self._oag)
self._glets.append(g)
gevent.sleep(0)
# Avoid double RPC initialization
self._rpc_init_done = True
# Proxying
if self._proxy_url:
self._proxy_mode = True
#@author:九世
#@file:scan.py
#@time: 2019/9/23
from gevent import monkey;monkey.patch_all()
from multiprocessing import Process
import requests
import sys
import gevent
import os
class Gz(object):
def __init__(self):
self.guanjianzi='haq5201314'
self.payload='c3lzdGVtKCJlY2hvIGhhcTUyMDEzMTQiKTs='
self.headers={'user-agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3314.0 Safari/537.36 SE 2.X MetaSr 1.0',
'Accept-Encoding':'gzip,deflate',
'Accept-Charset':'c3lzdGVtKCJlY2hvIGhhcTUyMDEzMTQiKTs='}
self.calc=0
self.djcs=[]
self.xcs=[]
def scan_query(self,url):
try:
rqt=requests.get(url=url,headers=self.headers)
if self.guanjianzi in rqt.text:
print('[ok] 存在PHPstudy 后门漏洞,url:{}'.format(rqt.url))
else:
print('[no] 不存在后门,url:{}'.format(rqt.url))
except Exception as r:
print('[Error] {}'.format(r))
from gevent import monkey # isort:skip
monkey.patch_all() # isort:skip
from time import sleep # noqa: E402
from simple_amqp import AmqpMsg, AmqpParameters # noqa: E402
from simple_amqp.gevent import GeventAmqpConnection # noqa: E402
FIRST_COUNT = 0
SECOND_COUNT = 0
def consumer(msg: AmqpMsg):
global FIRST_COUNT
global SECOND_COUNT
payload = msg.payload
payload = payload.decode()
if payload == 'first':
FIRST_COUNT += 1
if payload == 'second':
SECOND_COUNT += 1
print('msg received: {}'.format(payload))
# acknowledge that the message was received correctly
return True
def main():
conn = GeventAmqpConnection(AmqpParameters())
channel = conn.channel()
# Make external libs work with gevent, but still enable real threading
from gevent import monkey # isort:skip
monkey.patch_all(thread=False) # noqa: E702 isort:skip
# Make postgresql usable with gevent
import psycogreen.gevent # isort:skip
psycogreen.gevent.patch_psycopg() # noqa: E702 isort:skip
import json
import logging
import logging.config
import os
import click
import toml
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler
from relay.relay import TrustlinesRelay
from relay.utils import get_version
from .api.app import ApiApp
logger = logging.getLogger("trustlines")
def patch_warnings_module():
"""patch the warnings modules simplefilter function
the web3 module prints excessive deprecation warnings. They call
from gevent import monkey # isort:skip # noqa
monkey.patch_all(subprocess=False, thread=False) # isort:skip # noqa
import os.path
import sys
import click
import structlog
from request_collector.server import RequestCollector
from monitoring_service.database import SharedDatabase
from raiden.utils.cli import NetworkChoiceType
from raiden_libs.cli import common_options, setup_sentry
log = structlog.get_logger(__name__)
@click.command()
@click.option(
"--chain-id",
type=NetworkChoiceType(
["mainnet", "ropsten", "rinkeby", "goerli", "kovan", "<NETWORK_ID>"]),
required=True,
show_default=True,
help=(
"Specify the chain name/id of the Ethereum network to run Raiden on.\n"
"Available networks:\n"
'"mainnet" - network id: 1\n'
'"ropsten" - network id: 3\n'
'"rinkeby" - network id: 4\n'
from gevent import monkey
monkey.patch_all(thread=False)
import psycogreen.gevent
psycogreen.gevent.patch_psycopg()
import pytest
from flask.testing import FlaskClient
from app import create_app
from .utils import JSONResponse
@pytest.fixture(scope='module')
def flask_app():
app = create_app(environment='testing')
from app.database import db
with app.app_context():
db.create_all()
yield app
db.session.close_all()
db.drop_all()
@pytest.fixture(scope='module')
def client(flask_app):
app = flask_app
ctx = flask_app.test_request_context()
# Included modules
import os
import sys
import time
import logging
# Third party modules
import gevent
from gevent import monkey
if "patch_subprocess" in dir(monkey):
monkey.patch_all(thread=False, subprocess=False)
else:
monkey.patch_all(thread=False)
# Not thread: pyfilesystem and systray icon, Not subprocess: Gevent 1.1+
update_after_shutdown = False # If set True then update and restart zeronet after main loop ended
# Load config
from Config import config
config.parse(silent=True) # Plugins need to access the configuration
if not config.arguments: # Config parse failed, show the help screen and exit
config.parse()
# Create necessary files and dirs
if not os.path.isdir(config.log_dir):
os.mkdir(config.log_dir)
if not os.path.isdir(config.data_dir):
os.mkdir(config.data_dir)
if not os.path.isfile("%s/sites.json" % config.data_dir):
open("%s/sites.json" % config.data_dir, "w").write("{}")
#!/bin/python
import configparser, time, json, os, socket
import paho.mqtt.client as mqtt
from bottle import route, request, run, Jinja2Template, jinja2_view, static_file, GeventServer, response, get, HTTPResponse
from gevent import monkey, sleep; monkey.patch_all()
# Get current time in seconds
sec_time = lambda: int(time.time())
config = configparser.ConfigParser()
server_ip = "0.0.0.0"
server_port = 8080
mqtt_broker = server_ip
broker_port = 1883
modules = []
rooms = []
def parse_bool(s):
if str(s).lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif str(s).lower() in ('no', 'false', 'f', 'n', '0'):
return False
def on_mqtt_message(client, userdata, message):
for module in modules:
light_topic = "intarnetto/module_" + module.code + "/status"
mpd_topic = "mpd/module_" + module.code + "/status"
if message.topic == light_topic:
m_message = str(message.payload.decode("utf-8"))
module.set_status(parse_bool(m_message))
#-*- coding: utf-8 -*-
import gevent
from gevent import monkey
monkey.patch_all(thread=True)
import os
import sys
from os.path import abspath, dirname
sys.path.insert(0, dirname(dirname(abspath(__file__))))
import datetime
import matplotlib
matplotlib.use('Agg')
import const as ct
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from backlooking.cdoc import CDoc
from matplotlib import style
from climit import CLimit
from cindex import CIndex
from cmysql import CMySQL
from datetime import datetime
from rstock import RIndexStock
from base.clog import getLogger
from datamanager.margin import Margin
from rindustry import RIndexIndustryInfo
from industry_info import IndustryInfo
from datamanager.emotion import Emotion
from datamanager.sexchange import StockExchange
from common import create_redis_obj, get_chinese_font, get_tushare_client, get_day_nday_ago
# fmt: off
from gevent.monkey import patch_all; patch_all()
# fmt: on
import base64
import hashlib
import json
import os
import traceback
from itertools import chain
from urllib.parse import parse_qsl
import redis
import requests
from pywb.apps.frontendapp import FrontEndApp
from pywb.apps.wbrequestresponse import WbResponse
from pywb.manager.manager import CollectionsManager
from pywb.rewrite.templateview import BaseInsertView
from warcio.timeutils import timestamp_now, timestamp_to_iso_date
from werkzeug.routing import Rule
EMPTY_LIST = []
EMPTY_DICT = {}
SKIPPED_NODES = {'script', 'style'}
TITLE = 'title'
TEXT = '#text'
# ============================================================================
def extract_text(node, metadata=None):
node_name = node.get('nodeName', '').lower()
if node_name not in SKIPPED_NODES:
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
eventlet_socket = eventlet.listen((host, port))
# 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:
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)
if use_reloader:
# monkey patching is required by the reloader
from gevent import monkey
monkey.patch_all()
def run_server():
self.wsgi_server.serve_forever()
run_with_reloader(run_server, extra_files=extra_files)
else:
self.wsgi_server.serve_forever()
from Models import User
from flask.ext.cors import CORS
from flask import send_file, send_from_directory
from flask import request, jsonify, abort, Response, g
from flask_socketio import SocketIO, join_room
from Auth import *
from Models import *
from DownloadManager import *
import json, urllib.request, urllib.error, urllib.parse, os, _thread
from multiprocessing import Process
from DownloadDaemon import starter
from EMail import send_mail
import sys
from gevent import monkey
monkey.patch_all(ssl=False)
server = Flask(__name__)
server.config['SECRET_KEY'] = "123456789"
socketio = SocketIO(server, debug=True, logger=True, engineio_logger=True, ping_timeout=600)
cors = CORS(server)
p = None
verbose = False
if len(sys.argv) == 2 and sys.argv[1] == '-v':
verbose = True
def token_validator(token):
user = verify_auth_token(token, server.config['SECRET_KEY'])
if user != None:
g.user = user
from gevent import monkey
monkey.patch_all() #指的是在运行时动态替换
import gevent
from urllib import request
import time
def f(url):
print('GET: %s' % url)
resp = request.urlopen(url)
data = resp.read()
print('%d bytes received from %s.' % (len(data), url))
start = time.time()
gevent.joinall([
gevent.spawn(f, 'https://itk.org/'),
gevent.spawn(f, 'https://www.github.com/'),
gevent.spawn(f, 'https://zhihu.com/'),
])
print(time.time() - start)
from gevent import monkey
monkey.patch_all(dns=False)
from .orchestra import monkey
monkey.patch_all()
import logging
import os
import sys
__version__ = '0.1.0'
# If we are running inside a virtualenv, ensure we have its 'bin' directory in
# our PATH. This doesn't happen automatically if scripts are called without
# first activating the virtualenv.
exec_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
if os.path.split(exec_dir)[-1] == 'bin' and exec_dir not in os.environ['PATH']:
os.environ['PATH'] = ':'.join((exec_dir, os.environ['PATH']))
# We don't need to see log entries for each connection opened
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(
logging.WARN)
# if requests doesn't bundle it, shut it up anyway
logging.getLogger('urllib3.connectionpool').setLevel(
logging.WARN)
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s.%(msecs)03d %(levelname)s:%(name)s:%(message)s')
log = logging.getLogger(__name__)
