def run(config, section_name): import eventlet # Apply monkey_patch at the earliest eventlet.monkey_patch(thread=False) ''' Sets up logging for the entire process and then starts the corresponding handler. - config : Configuration of the application. - section_name : Name of the section in the config. ''' logUtils.setup_logging(config) logger = logUtils.get_logger(__name__) solr_url = config['DEFAULT']['solr_url'] db_info = session.DBInfo(config['DEFAULT']['nova_db_server'], config['DEFAULT']['nova_db_port'], config['DEFAULT']['nova_db_creds']) amqp_info = amqp_client.AmqpInfo(config['DEFAULT']['amqp_server'], config['DEFAULT']['amqp_port'], config['DEFAULT']['amqp_creds']) # pull out name of the handler for the specific core section = config[section_name] handlerName = section["handlerName"] interval = int(section["interval"]) try : # instantiate the handler handlerKls = get_class(handlerName) handler = handlerKls(solr_url, db_info, amqp_info, interval) logger.info(str(handler) + ' instantiated to perform work.') # handler is expected to have an on_start & setup_amqp() method to do the real work. # run on_start on a green thread. eventlet.spawn_n(handler.on_start) # call setup_amqp on the main thread so that it keeps the main thread busy. handler.setup_amqp() return handler except Exception as inst: logger.exception(inst)
def main(): cfg.parse_args(sys.argv) logging.setup(CONF, None) debug_utils.setup() # Patch 'thread' module if debug is disabled if not debug_utils.enabled(): eventlet.monkey_patch(thread=True) from trove.guestagent import dbaas manager = dbaas.datastore_registry().get(CONF.datastore_manager) if not manager: msg = ("Manager class not registered for datastore manager %s" % CONF.datastore_manager) raise RuntimeError(msg) # rpc module must be loaded after decision about thread monkeypatching # because if thread module is not monkeypatched we can't use eventlet # executor from oslo_messaging library. from trove import rpc rpc.init(CONF) from trove.common.rpc import service as rpc_service from trove.common.rpc import version as rpc_version server = rpc_service.RpcService( manager=manager, host=CONF.guest_id, rpc_api_version=rpc_version.RPC_API_VERSION) launcher = openstack_service.launch(CONF, server) launcher.wait()
def main(): eventlet.monkey_patch() cfg.CONF(project='neutron') logging_config.setup_logging(cfg.CONF) try: interface_mappings = q_utils.parse_mappings( cfg.CONF.ESWITCH.physical_interface_mappings) except ValueError as e: LOG.error(_("Parsing physical_interface_mappings failed: %s." " Agent terminated!"), e) sys.exit(1) LOG.info(_("Interface mappings: %s"), interface_mappings) try: agent = MlnxEswitchNeutronAgent(interface_mappings) except Exception as e: LOG.error(_("Failed on Agent initialisation : %s." " Agent terminated!"), e) sys.exit(1) # Start everything. LOG.info(_("Agent initialised successfully, now running... ")) agent.daemon_loop() sys.exit(0)
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 __init__(self, listener, application=None, backlog=None): eventlet.monkey_patch() host, port = listener self.socket = create_socket(host, port, self.address_family, self.socket_type, backlog=backlog) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.application = application
def main(): eventlet.monkey_patch() cfg.CONF.register_opts(ip_lib.OPTS) cfg.CONF(project='neutron') logging_config.setup_logging(cfg.CONF) legacy.modernize_quantum_config(cfg.CONF) try: agent_config = create_agent_config_map(cfg.CONF) except ValueError as e: LOG.error(_('%s Agent terminated!'), e) sys.exit(1) is_xen_compute_host = 'rootwrap-xen-dom0' in agent_config['root_helper'] if is_xen_compute_host: # Force ip_lib to always use the root helper to ensure that ip # commands target xen dom0 rather than domU. cfg.CONF.set_default('ip_lib_force_root', True) plugin = OVSNeutronAgent(**agent_config) # Start everything. LOG.info(_("Agent initialized successfully, now running... ")) plugin.daemon_loop() sys.exit(0)
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 setup(url=None, optional=False): """Initialise the oslo.messaging layer.""" global TRANSPORT, NOTIFIER if url and url.startswith("fake://"): # NOTE(sileht): oslo.messaging fake driver uses time.sleep # for task switch, so we need to monkey_patch it eventlet.monkey_patch(time=True) if not TRANSPORT: oslo.messaging.set_transport_defaults('heat') exmods = ['heat.common.exception'] try: TRANSPORT = oslo.messaging.get_transport( cfg.CONF, url, allowed_remote_exmods=exmods, aliases=_ALIASES) except oslo.messaging.InvalidTransportURL as e: TRANSPORT = None if not optional or e.url: # NOTE(sileht): oslo.messaging is configured but unloadable # so reraise the exception raise if not NOTIFIER and TRANSPORT: serializer = RequestContextSerializer(JsonPayloadSerializer()) NOTIFIER = oslo.messaging.Notifier(TRANSPORT, serializer=serializer)
def main(): eventlet.monkey_patch() cfg.CONF(args=sys.argv, project='quantum') # (TODO) gary - swap with common logging logging_config.setup_logging(cfg.CONF) interface_mappings = {} for mapping in cfg.CONF.LINUX_BRIDGE.physical_interface_mappings: try: physical_network, physical_interface = mapping.split(':') interface_mappings[physical_network] = physical_interface LOG.debug("physical network %s mapped to physical interface %s" % (physical_network, physical_interface)) except ValueError as ex: LOG.error("Invalid physical interface mapping: %s - %s. " "Agent terminated!" % (mapping, ex)) sys.exit(1) polling_interval = cfg.CONF.AGENT.polling_interval root_helper = cfg.CONF.AGENT.root_helper plugin = LinuxBridgeQuantumAgentRPC(interface_mappings, polling_interval, root_helper) LOG.info("Agent initialized successfully, now running... ") plugin.daemon_loop() sys.exit(0)
def main(): """Main method for cleaning up network namespaces. This method will make two passes checking for namespaces to delete. The process will identify candidates, sleep, and call garbage collect. The garbage collection will re-verify that the namespace meets the criteria for deletion (ie it is empty). The period of sleep and the 2nd pass allow time for the namespace state to settle, so that the check prior deletion will re-confirm the namespace is empty. The utility is designed to clean-up after the forced or unexpected termination of Quantum agents. The --force flag should only be used as part of the cleanup of a devstack installation as it will blindly purge namespaces and their devices. This option also kills any lingering DHCP instances. """ eventlet.monkey_patch() conf = setup_conf() conf(sys.argv) # Identify namespaces that are candidates for deletion. candidates = [ns for ns in ip_lib.IPWrapper.get_namespaces(conf.root_helper) if eligible_for_deletion(conf, ns, conf.force)] if candidates: eventlet.sleep(2) for namespace in candidates: destroy_namespace(conf, namespace, conf.force)
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 _monkey_patch(): eventlet.monkey_patch( os=True, select=True, socket=True, thread=False if '--use-debugger' in sys.argv else True, time=True)
def prepare_service(argv=None): eventlet.monkey_patch() gettextutils.install('gringotts', lazy=False) # Override the default control_exchange, default is 'openstack' rpc.set_defaults(control_exchange='gringotts') cfg.set_defaults(log.log_opts, default_log_levels=['amqplib=WARN', 'qpid.messaging=INFO', 'sqlalchemy=WARN', 'keystoneclient=INFO', 'stevedore=INFO', 'eventlet.wsgi.server=WARN' ]) if argv is None: argv = sys.argv cfg.CONF(argv[1:], project='gringotts') log.setup('gringotts') #NOTE(suo): Import services/submodules to register methods # If use `from gringotts.services import *` will cause SynaxWarning, # so we import every submodule implicitly. from gringotts import services for m in services.SUBMODULES: importutils.import_module("gringotts.services.%s" % m) LOG.warn('Loaded resources: %s' % services.RESOURCE_GET_MAP.keys())
def main(): eventlet.monkey_patch() # the configuration will be read into the cfg.CONF global data structure config.parse(sys.argv[1:]) if not cfg.CONF.config_file: sys.exit( _( "ERROR: Unable to find configuration file via the default" " search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and" " the '--config-file' option!" ) ) try: pool = eventlet.GreenPool() neutron_api = service.serve_wsgi(service.NeutronApiService) api_thread = pool.spawn(neutron_api.wait) try: neutron_rpc = service.serve_rpc() except NotImplementedError: LOG.info(_("RPC was already started in parent process by plugin.")) else: rpc_thread = pool.spawn(neutron_rpc.wait) # api and rpc should die together. When one dies, kill the other. rpc_thread.link(lambda gt: api_thread.kill()) api_thread.link(lambda gt: rpc_thread.kill()) pool.waitall() except KeyboardInterrupt: pass except RuntimeError as e: sys.exit(_("ERROR: %s") % e)
def main(): eventlet.monkey_patch() cfg.CONF(project='neutron') # fix-neutron-agent-for-mtu-config hack cfg.CONF.register_opts(interface.OPTS) logging_config.setup_logging(cfg.CONF) LOG.info(_("network_device_mtu: %s"), str(cfg.CONF.network_device_mtu)) try: interface_mappings = q_utils.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error(_("Parsing physical_interface_mappings failed: %s." " Agent terminated!"), e) sys.exit(1) LOG.info(_("Interface mappings: %s"), interface_mappings) polling_interval = cfg.CONF.AGENT.polling_interval root_helper = cfg.CONF.AGENT.root_helper agent = LinuxBridgeNeutronAgentRPC(interface_mappings, polling_interval, root_helper) LOG.info(_("Agent initialized successfully, now running... ")) agent.daemon_loop() sys.exit(0)
def main(): eventlet.monkey_patch() opts = [ cfg.StrOpt('network_id'), cfg.StrOpt('router_id'), cfg.StrOpt('pid_file'), cfg.BoolOpt('daemonize', default=True), cfg.IntOpt('metadata_port', default=9697, help=_("TCP Port to listen for metadata server " "requests.")), ] cfg.CONF.register_cli_opts(opts) # Don't get the default configuration file cfg.CONF(project='neutron', default_config_files=[]) config.setup_logging(cfg.CONF) utils.log_opt_values(LOG) proxy = ProxyDaemon(cfg.CONF.pid_file, cfg.CONF.metadata_port, network_id=cfg.CONF.network_id, router_id=cfg.CONF.router_id) if cfg.CONF.daemonize: proxy.start() else: proxy.run()
def init(): import eventlet def eval_from_file(path_obj): """Evaluate sexpression in given file. """ with path_obj.open() as fobj: expr = fobj.read() eval_sexp_str(expr) if platform().lower().startswith('win'): eventlet.monkey_patch(os=False) else: eventlet.monkey_patch() expr_path = Path(__file__).absolute().parents[1] / 'sexpressions' eval_from_file(expr_path / 'main.expr') if not IS_PYPY: eval_from_file(expr_path / 'cpython.expr') else: eval_from_file(expr_path / 'pypy.expr') eval_from_file(expr_path / 'del_hidden.expr') for syntax in {'for', 'each', 'while', 'break', 'continue'}: del syntax_table[syntax] del global_env[syntax] del global_scope[syntax] sys.path.append(os.getcwd())
def _patch_eventlet(): import eventlet import eventlet.debug eventlet.monkey_patch() EVENTLET_DBLOCK = int(os.environ.get('EVENTLET_NOBLOCK', 0)) if EVENTLET_DBLOCK: eventlet.debug.hub_blocking_detection(EVENTLET_DBLOCK)
def main(): eventlet.monkey_patch() opts = [ cfg.StrOpt('network_id'), cfg.StrOpt('router_id'), cfg.StrOpt('pid_file'), cfg.BoolOpt('daemonize', default=True), cfg.IntOpt('metadata_port', default=9697, help="TCP Port to listen for metadata server requests."), ] cfg.CONF.register_cli_opts(opts) cfg.CONF(project='quantum') config.setup_logging(cfg.CONF) proxy = ProxyDaemon(cfg.CONF.pid_file, cfg.CONF.metadata_port, network_id=cfg.CONF.network_id, router_id=cfg.CONF.router_id) if cfg.CONF.daemonize: proxy.start() else: proxy.run()
def main(): eventlet.monkey_patch() cfg.CONF(project='neutron') logging_config.setup_logging(cfg.CONF) integ_br = cfg.CONF.OVS.integration_bridge polling_interval = cfg.CONF.AGENT.polling_interval root_helper = cfg.CONF.AGENT.root_helper tunnel_ip = _get_tunnel_ip() LOG.debug(_('tunnel_ip %s'), tunnel_ip) ovsdb_port = cfg.CONF.OVS.ovsdb_port LOG.debug(_('ovsdb_port %s'), ovsdb_port) ovsdb_ip = _get_ovsdb_ip() LOG.debug(_('ovsdb_ip %s'), ovsdb_ip) try: agent = OVSNeutronOFPRyuAgent(integ_br, tunnel_ip, ovsdb_ip, ovsdb_port, polling_interval, root_helper) except httplib.HTTPException as e: LOG.error(_("Initialization failed: %s"), e) sys.exit(1) LOG.info(_("Ryu initialization on the node is done. " "Agent initialized successfully, now running...")) agent.daemon_loop() sys.exit(0)
def main(): eventlet.monkey_patch() parser = argparse.ArgumentParser() parser.add_argument("-D", "--no-daemon", help="don't daemonize", action="store_false", dest='daemonize', default=True) parser.add_argument("config_file", help="Proxy configuration file") args = parser.parse_args() try: config_dict = json.load(open(args.config_file)) except IOError: raise SystemError('Unable to open config file at %s.' % args.config_file) except: raise SystemError('Unable to parse config file at %s.' % args.config_file) if args.daemonize: daemonize() pool = eventlet.GreenPool(1000) tenant_id = config_dict.pop('tenant_id') for network_id, config in config_dict.items(): app = NetworkMetadataProxyHandler(tenant_id, network_id, config['ip_instance_map']) socket = eventlet.listen(('127.0.0.1', config['listen_port']), backlog=128) pool.spawn_n(eventlet.wsgi.server, socket, app, custom_pool=pool) pool.waitall()
def get_realtime_bid_ask(code, index=0, proxy=None, timeout=5): index %= 2 if not proxy: proxies = None elif proxy[0:5] == "https": proxies = { "https" : proxy } else: proxies = { "http" : proxy } if index == 0: params = { "list" : "rt_hk%05d" % code } headers = { "Referer" : "http://stock.finance.sina.com.cn/hkstock/quotes/%05d.html" % code } try: eventlet.monkey_patch(all=False, os=False, select=False, socket=True, thread=False, time=False) with eventlet.Timeout(timeout): req = requests.get("http://hq.sinajs.cn/", params=params, headers=headers, proxies=proxies, timeout=timeout) except: return None if not req or req.status_code != requests.codes.ok: return None try: tokens = req.text.split(",") return (datetime.now().timestamp(), float(tokens[9]), float(tokens[10])) except: return None else: return None
def main(): class SimpleDaemon(daemon.Daemon): """The purpose of this daemon is to serve as an example, and also as a dummy daemon, which can be invoked by functional testing, it does nothing but setting the pid file, and staying detached in the background. """ def run(self): while True: eventlet.sleep(10) eventlet.monkey_patch() opts = [ cfg.StrOpt('uuid', help=_('uuid provided from the command line ' 'so external_process can track us via /proc/' 'cmdline interface.'), required=True), cfg.StrOpt('pid_file', help=_('Location of pid file of this process.'), required=True) ] cfg.CONF.register_cli_opts(opts) # Don't get the default configuration file cfg.CONF(project='neutron', default_config_files=[]) simple_daemon = SimpleDaemon(cfg.CONF.pid_file, uuid=cfg.CONF.uuid) simple_daemon.start()
def setup(cls): import eventlet if eventlet.version_info < (0, 9, 7): raise RuntimeError("You need eventlet >= 0.9.7") eventlet.monkey_patch(os=False) patch_sendfile()
def _kombu_mongo_open(self, scheme='mongodb://'): hostname, dbname, options = self._parse_uri(scheme=scheme) options.pop('auto_start_request', None) 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( host=hostname, ssl=options['ssl'], connectTimeoutMS=options['connectTimeoutMS'], ) 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 initialize(extra_opts=None, pre_logging=None): # Initialize localization support (the underscore character). import gettext gettext.install('transformer', unicode=1) # Apply whole eventlet.monkey_patch excluding 'thread' module. # Decision for 'thread' module patching will be made # after debug_utils is set up. import eventlet eventlet.monkey_patch(all=True, thread=False) # Import only the modules necessary to initialize logging and determine if # debug_utils are enabled. import sys from transformer.common import cfg from transformer.openstack.common import log as logging conf = cfg.CONF if extra_opts: conf.register_cli_opts(extra_opts) cfg.parse_args(sys.argv) if pre_logging: pre_logging(conf) logging.setup(None) # Initialize Transformer database. # from transformer.db import get_db_api # get_db_api().configure_db(conf) return conf # May be used by other scripts
def server(host=RESTAPI_DEFAULT_ADDRESS, port=RESTAPI_DEFAULT_PORT, server_name="wsgiref"): """ REST-JSON API server """ DataStore.admin_id = hexencode(os.urandom(16)) Database.filepath = tempfile.mkstemp(prefix="sqlmapipc-", text=False)[1] 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 server_name == "gevent": from gevent import monkey monkey.patch_all() elif server_name == "eventlet": import eventlet eventlet.monkey_patch() logger.debug("use {0} adapter run bottle".format(server_name)) run(host=host, port=port, quiet=True, debug=False, server=server_name) except socket.error, ex: if "already in use" in getSafeExString(ex): logger.error("Address already in use ('%s:%s')" % (host, port)) else: raise
def main(): eventlet.monkey_patch() cfg.CONF(args=sys.argv, project='quantum') # (TODO) gary - swap with common logging logging_config.setup_logging(cfg.CONF) try: interface_mappings = q_utils.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error(_("Parsing physical_interface_mappings failed: %s." " Agent terminated!"), e) sys.exit(1) LOG.info(_("Interface mappings: %s") % interface_mappings) polling_interval = cfg.CONF.AGENT.polling_interval reconnect_interval = cfg.CONF.DATABASE.reconnect_interval root_helper = cfg.CONF.AGENT.root_helper rpc = cfg.CONF.AGENT.rpc if rpc: plugin = LinuxBridgeQuantumAgentRPC(interface_mappings, polling_interval, root_helper) else: db_connection_url = cfg.CONF.DATABASE.sql_connection plugin = LinuxBridgeQuantumAgentDB(interface_mappings, polling_interval, reconnect_interval, root_helper, db_connection_url) LOG.info("Agent initialized successfully, now running... ") plugin.daemon_loop() sys.exit(0)
def main(): try: eventlet.monkey_patch(os=False) # the configuration will be into the cfg.CONF global data structure config.parseArgs(args=sys.argv[1:], default_config_files=["/etc/synergy/synergy.conf"]) if not cfg.CONF.config_file: sys.exit("ERROR: Unable to find configuration file via the " "default search paths (~/.synergy/, ~/, /etc/synergy/" ", /etc/) and the '--config-file' option!") setLogger(name="synergy") setLogger(name="oslo.messaging._drivers") global LOG LOG = logging.getLogger(__name__) LOG.info("Starting Synergy...") server = Synergy() server.start() LOG.info("Synergy started") except Exception as ex: LOG.error("unrecoverable error: %s" % ex)
def eventlet_monkey_patch(): """Apply eventlet's monkey patch. This call should be the first call in application. It's safe to call monkey_patch multiple times. """ eventlet.monkey_patch(**EVENTLET_MONKEY_PATCH_MODULES)
'settings', 'application', 'Middleware', 'dispatch', 'version', 'get_services', 'get_service_dir', ] version = '0.0.1' import sys reload(sys) sys.setdefaultencoding('utf-8') #@UndefinedVariable import eventlet eventlet.monkey_patch() class ServosError(Exception): pass class Middleware(object): ORDER = 500 def __init__(self, application, settings): self.application = application self.settings = settings import servos.core.dispatch as dispatch
from os.path import join as path_join from unittest import main from uuid import uuid4 from eventlet import GreenPool, Timeout import eventlet from sqlite3 import connect from swiftclient import client from swift.common import direct_client from swift.common.exceptions import ClientException from swift.common.utils import hash_path, readconf from test.probe.common import kill_nonprimary_server, \ kill_server, ReplProbeTest, start_server eventlet.monkey_patch(all=False, socket=True) def get_db_file_path(obj_dir): files = sorted(listdir(obj_dir), reverse=True) for filename in files: if filename.endswith('db'): return path_join(obj_dir, filename) class TestContainerFailures(ReplProbeTest): def test_one_node_fails(self): # Create container1 container1 = 'container-%s' % uuid4() cpart, cnodes = self.container_ring.get_nodes(self.account, container1) client.put_container(self.url, self.token, container1)
# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """ :mod:`Ironic.tests` -- ironic Unittests ===================================================== .. automodule:: ironic.tests :platform: Unix """ # TODO(deva): move eventlet imports to ironic.__init__ once we move to PBR import eventlet eventlet.monkey_patch(os=False) # See http://code.google.com/p/python-nose/issues/detail?id=373 # The code below enables nosetests to work with i18n _() blocks import __builtin__ setattr(__builtin__, '_', lambda x: x)
def tearDownClass(cls): eventlet.monkey_patch(os=False, select=False, socket=False, thread=False, time=False)
import hashlib import base64 import six import eventlet import easyimap from flanker import mime from st2reactor.sensor.base import PollingSensor __all__ = ['IMAPSensor'] eventlet.monkey_patch(os=True, select=True, socket=True, thread=True, time=True) DEFAULT_DOWNLOAD_ATTACHMENTS = False DEFAULT_MAX_ATTACHMENT_SIZE = 1024 DEFAULT_ATTACHMENT_DATASTORE_TTL = 1800 class IMAPSensor(PollingSensor): def __init__(self, sensor_service, config=None, poll_interval=10): super(IMAPSensor, self).__init__(sensor_service=sensor_service, config=config, poll_interval=poll_interval) self._trigger = 'email.imap.message' self._logger = self._sensor_service.get_logger(__name__)
# noinspection PyUnresolvedReferences from oslo_service import service # noinspection PyUnresolvedReferences from oslo_service.periodic_task import PeriodicTasks # noinspection PyUnresolvedReferences from cephclient import wrapper from ceph_manager.monitor import Monitor from ceph_manager import constants from ceph_manager.i18n import _LI from ceph_manager.i18n import _LW from retrying import retry eventlet.monkey_patch(all=True) CONF = cfg.CONF CONF.register_opts([ cfg.StrOpt('sysinv_api_bind_ip', default='0.0.0.0', help='IP for the Ceph Manager server to bind to') ]) CONF.logging_default_format_string = ('%(asctime)s.%(msecs)03d %(process)d ' '%(levelname)s %(name)s [-] %(message)s') logging.register_options(CONF) logging.setup(CONF, __name__) LOG = logging.getLogger(__name__) CONF.rpc_backend = 'rabbit'
import eventlet from eventlet import tpool eventlet.monkey_patch() # noqa from os_win import utilsfactory from os_win.utils.compute import _clusapi_utils from os_win.utils.compute import clusterutils import wmi import argparse import json import time import logging parser = argparse.ArgumentParser() parser.add_argument('--log-file', required=False) args = parser.parse_args() LOG = logging.getLogger() def setup_logging(): log_level = logging.DEBUG handler = logging.StreamHandler() handler.setLevel(log_level) log_fmt = '[%(asctime)s] %(levelname)s - %(message)s' formatter = logging.Formatter(log_fmt) handler.setFormatter(formatter)
import eventlet eventlet.monkey_patch(socket=False) from flask import Flask from flask_socketio import SocketIO from flask_cors import CORS app = Flask(__name__, static_folder='image', static_url_path='/image') CORS(app, supports_credentials=True) UPLOAD_FOLDER = 'image/' STATIC_FOLDER = 'https://keelung-eat.herokuapp.com/image/' app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER app.config['STATIC_FOLDER'] = STATIC_FOLDER socketio = SocketIO(app, cors_allowed_origins='*') import KeelungEat.http_route import KeelungEat.ws_route import KeelungEat.background_task
import eventlet eventlet.monkey_patch(thread=False) import sys import workers from config import Config from database import (connect_mongo, ImageModel, create_from_json) from flask import Flask from flask_cors import CORS from flask_socketio import SocketIO from werkzeug.contrib.fixers import ProxyFix from celery import Celery from .watcher import run_watcher from .api import blueprint as api from .util import query_util from .authentication import login_manager from .sockets import socketio import threading import requests import logging import time import os connect_mongo('webserver')
import time from threading import Thread, Event from flask import Flask, flash, render_template, request, redirect, Response from flask_socketio import SocketIO, join_room, emit, send import eventlet import picommon from pistrobe import PiStrobe from piholder_web import heater_web #from camera import Camera from camera_base import CameraBase from camera_pi import Camera #from vimba_pi import Camera from piflow_web import flow_web eventlet.monkey_patch( os=True, select=True, socket=True, thread=False, time=True, psycopg=True ) #eventlet.monkey_patch() exit_event = Event() picommon.spi_init( 0, 2, 30000 ) debug_data = { 'update_count': 0 } heaters_data = [ { 'status': '', 'temp_text': '', 'temp_c_actual': 0.0, 'temp_c_target': 0.0, 'pid_enabled': False, 'power_limit': 0, 'autotune_status': '', 'autotune_target_temp': 0.0, 'autotuning': False, 'stir_speed_text': '', 'stir_speed_target': 0, 'stir_enabled': False } for i in range(4) ] heater1 = heater_web( 1, picommon.PORT_HEATER1 ) heater2 = heater_web( 2, picommon.PORT_HEATER2 ) heater3 = heater_web( 3, picommon.PORT_HEATER3 ) heater4 = heater_web( 4, picommon.PORT_HEATER4 ) heaters = [heater1, heater2, heater3, heater4]
from st2common.service_setup import deregister_service from st2common.stream.listener import get_listener_if_set from st2common.util.wsgi import shutdown_server_kill_pending_requests from st2stream.signal_handlers import register_stream_signal_handlers from st2stream import config config.register_opts(ignore_errors=True) from st2stream import app __all__ = ["main"] eventlet.monkey_patch( os=True, select=True, socket=True, thread=False if "--use-debugger" in sys.argv else True, time=True, ) LOG = logging.getLogger(__name__) STREAM = "stream" # How much time to give to the request in progress to finish in seconds before killing them WSGI_SERVER_REQUEST_SHUTDOWN_TIME = 2 def _setup(): capabilities = { "name": "stream", "listen_host": cfg.CONF.stream.host,
def skip_timeout(program,timeout): eventlet.monkey_patch() with eventlet.Timeout(timeout,False): time.sleep(4) subprocess.call(program,shell=True)
# 1,协程打补丁,将IO操作变为异步 from eventlet import monkey_patch monkey_patch() import socketio # 2,创建socketio服务器 sio = socketio.Server(async_model='eventlet') # sio = socketio.AsyncServer() # app = socketio.ASGIApp(sio) # app = socketio.WSGIApp(sio,app) # 3,创建应用,管理im服务器 app = socketio.Middleware(sio) # 4,监听端口 import eventlet.wsgi sock = eventlet.listen(('192.168.59.129', 9000)) @sio.event def connect(sid, environ): print('连接时自动调用') print('+++', sid, environ) @sio.event def disconnect(sid): print('断开连接时调用', sid)
#coding:utf-8 import time import eventlet #导入eventlet这个模块 eventlet.monkey_patch() #必须加这条代码 with eventlet.Timeout(2, False): #设置超时时间为2秒 time.sleep(1) print('没有跳过这条输出') print('跳过了输出')
# -*- coding:utf-8 -*- """ k线分钟线,5,10,60数据存储,不再批量更新 """ import pandas as pd import datetime import json import eventlet as et import constant as ct from utils.wapper_interface import gm_api as gm from pymongo import MongoClient from datetime import datetime from datetime import timedelta et.monkey_patch(os=False) class KminDbCache(): def __init__(self): # self.gm = gm() self.pool = et.GreenPool(10) def get_k_data(self, *args, **kwargs): """ :param args: args 第一项肯定为code :param kwargs: ktype,startdate等肯定包含在kwargs中 :return: 先读cache,如果最近时间大于请求时间,则返回,否则调用更新算法,只更新这一个code,更新数据库; 默认为5分钟线数据,一个文件一存 """ collection_name = 'k_data_'
def initialize_reactor(cls): eventlet.monkey_patch() if not cls._timers: cls._timers = TimerManager() cls._timeout_watcher = eventlet.spawn(cls.service_timeouts) cls._new_timer = Event()
def run_gunicorn_eventlet(): # this is taken from gunicorn EventletWorker.patch() import eventlet eventlet.monkey_patch(os=False) run_gunicorn()
#!/usr/bin/env python # -*- coding: utf-8 -*- # noinspection PyBroadException try: import eventlet eventlet.monkey_patch(all=True, thread=False) except: pass import argparse import itertools import logging import logging.config import os import signal import eventlet.wsgi import sqlalchemy_utils import yaml from flask import Flask, request, g as flask_g from flask_babel import get_locale, Babel from flask_babel import gettext from flask_cors import CORS from flask_migrate import Migrate from flask_restful import Api, abort from flask_swagger_ui import get_swaggerui_blueprint from limonero import CustomJSONEncoder as LimoneroJSONEncoder from limonero.cache import cache
def main(upgrade_api_args): if not upgrade_api_args.get("args_file", None): print( "\033[1;34mPlease set config file!! Default path is translate_src/conf/upgrade.conf\033[0m" ) exit(1) if not upgrade_api_args.get("modify_dict", None): print( "\033[1;34mPlease set modify_dict file!! Default path is translate_src/dict/modify.dict\033[0m" ) exit(1) upgrade_config_dict = load_config(upgrade_api_args["args_file"]) if not os.path.isfile(upgrade_config_dict["input_path"]): file_py_list = get_cur_file_list() else: file_py_list = upgrade_config_dict["input_path"] modify_dict = load_modify_dict(upgrade_api_args["modify_dict"]) delete_list = load_delete_dict(upgrade_api_args["delete_dict"]) delete_pattern = "|".join(delete_list) if isinstance(file_py_list, list): if PROCESS_OR_THREAD == "MULTI_PROCESS": executor = concurrent.futures.ProcessPoolExecutor( max_workers=MAX_WORKERS) future_list = [] for path in file_py_list: future = executor.submit(transformer_file, upgrade_config_dict, path, modify_dict, True, delete_pattern) # 生成future实例 future_list.append(future) elif PROCESS_OR_THREAD == "MULTI_THREAD": executor = concurrent.futures.ThreadPoolExecutor( max_workers=MAX_WORKERS) future_list = [] for path in file_py_list: future = executor.submit(transformer_file, upgrade_config_dict, path, modify_dict, True, delete_pattern) # 生成future实例 future_list.append(future) executor.shutdown() for future in concurrent.futures.as_completed(future_list): if future.exception() is not None: print_info( "\033[1;31m parallel error with future exception: %s \033[0m" % (future.exception())) else: future.result() print_info("\033[1;33m all done.\033[0m") elif file_py_list is None: print_info( "\033[1;31mInput error: input must be a directory or a python file\033[0m" ) else: try: eventlet.monkey_patch() with eventlet.Timeout(30, False): try: transformer_file(upgrade_config_dict, upgrade_config_dict["input_path"], modify_dict, is_dir=False, delete_pattern=delete_pattern) except Exception as e: print_info( "\033[1;31m %s upgrade error, please check file, use a replacement policy and convert it manually, with error %s. \033[0m" % (upgrade_config_dict["input_path"], e)) except Exception as e: print_info( "\033[1;31m %s upgrade timeout, please check file, use a replacement policy and convert it manually, with error %s.\033[0m" % (upgrade_config_dict["input_path"], e))
def patch(self): hubs.use_hub() eventlet.monkey_patch() patch_sendfile()
import eventlet import msgpack import flask from flask import (Flask, render_template, make_response, copy_current_request_context, jsonify, request) from flask_socketio import SocketIO from jinja2 import Environment, FileSystemLoader, ChoiceLoader from bowtie._component import Event, Component, COMPONENT_REGISTRY from bowtie.pager import Pager from bowtie.exceptions import (GridIndexError, NoSidebarError, NotStatefulEvent, NoUnusedCellsError, SpanOverlapError, SizeError, WebpackError, YarnError) eventlet.monkey_patch(time=True) Route = namedtuple('Route', ['view', 'path', 'exact']) _Import = namedtuple('_Import', ['module', 'component']) _DIRECTORY = Path('build') _WEBPACK = './node_modules/.bin/webpack' _MIN_NODE_VERSION = 6, 11, 5 class Scheduler: """Run scheduled tasks.""" def __init__(self, app, seconds, func): """Create a scheduled function.""" self.app = app self.seconds = seconds
#!/bin/env python import eventlet eventlet.monkey_patch() # Fix IO Block from simple_app import create_app, socketio from simple_app.main.schema import Schema app = create_app(debug=True) if __name__ == '__main__': Schema() socketio.run(app)
import eventlet eventlet.monkey_patch(subprocess=True) #from gevent import monkey #monkey.patch_all(subprocess=True) #import gevent import os import sys import importlib import static import templates import subprocess import json import random import requests import urlparse2 import time import hmac #import pylint_flask import functools import redis from python_path import PythonPath from cloudant.result import Result, ResultByKey from cloudant.query import Query, QueryResult #from AMQonlinestore.AMQ_Dba import cloudant_online_store
"""Run nameko services. Given a python path to a module containing one or more nameko services, will host and run them. By default this will try to find classes that look like services (anything with nameko entrypoints), but a specific service can be specified via ``nameko run module:ServiceClass``. """ from __future__ import print_function import eventlet eventlet.monkey_patch() # noqa (code before rest of imports) import errno import inspect import logging import logging.config import os import re import signal import sys import yaml from eventlet import backdoor from nameko.constants import AMQP_URI_CONFIG_KEY from nameko.exceptions import CommandError from nameko.extensions import ENTRYPOINT_EXTENSIONS_ATTR from nameko.runners import ServiceRunner from nameko.cli.reloader import run_with_reloader logger = logging.getLogger(__name__) MISSING_MODULE_TEMPLATE = "^No module named '?{}'?$"
def main(upgrade_api_args): if not upgrade_api_args.get("args_file", None): print( "\033[1;34mPlease set config file!! Default path is api_upgrade_src/conf/upgrade.conf\033[0m" ) exit(1) if not upgrade_api_args.get("modify_dict", None): print( "\033[1;34mPlease set modify_dict file!! Default path is api_upgrade_src/dict/modify.dict\033[0m" ) exit(1) upgrade_config_dict = load_config(upgrade_api_args["args_file"]) if not os.path.isfile(upgrade_config_dict["input_path"]): file_py_list = get_cur_file_list() else: file_py_list = upgrade_config_dict["input_path"] modify_dict = load_modify_dict(upgrade_api_args["modify_dict"]) delete_list = load_delete_dict(upgrade_api_args["delete_dict"]) delete_pattern = "|".join(delete_list) if isinstance(file_py_list, list): for path in file_py_list: content = open(path, 'r').readlines() match = re.search(delete_pattern, "\n".join(content)) if match: delete_api = match.group(0) print_info( "\033[1;31m %s API has been deleted, please check file %s, use a replacement policy and convert it manually\033[0m" % (delete_api, path)) else: try: eventlet.monkey_patch() with eventlet.Timeout(30, False): try: transformer_file(upgrade_config_dict, path, modify_dict, is_dir=True) except Exception as e: print_info( "\033[1;31m %s upgrade error, please check file, use a replacement policy and convert it manually, with error: %s. \033[0m" % (path, e)) except: print_info( "\033[1;31m %s upgrade timeout, please check file, use a replacement policy and convert it manually\033[0m" % (path)) elif file_py_list is None: print_info( "\033[1;31mInput error: input must be a directory or a python file\033[0m" ) else: content = open(upgrade_config_dict["input_path"], 'r').readlines() match = re.search(delete_pattern, "\n".join(content)) if match: delete_api = match.group(0) print_info( "\033[1;31m %s API has been deleted, please check file %s, use a replacement policy and convert it manually\033[0m" % (delete_api, upgrade_config_dict["input_path"])) else: try: eventlet.monkey_patch() with eventlet.Timeout(30, False): try: transformer_file(upgrade_config_dict, upgrade_config_dict["input_path"], modify_dict, is_dir=False) except: print_info( "\033[1;31m %s upgrade error, please check file, use a replacement policy and convert it manually\033[0m" % (upgrade_config_dict["input_path"])) except: print_info( "\033[1;31m %s upgrade timeout, please check file, use a replacement policy and convert it manually\033[0m" % (upgrade_config_dict["input_path"]))
def run_experiment(self): eventlet.monkey_patch(socket=True, thread=True) self.init_socks() self.run_server()
#!/usr/bin/env python import eventlet eventlet.monkey_patch(socket=True, select=True, time=True) import eventlet.wsgi import socketio import time from flask import Flask, render_template from bridge import Bridge from conf import conf sio = socketio.Server() app = Flask(__name__) msgs = [] dbw_enable = False @sio.on('connect') def connect(sid, environ): print("connect ", sid) def send(topic, data): s = 1 msgs.append((topic, data)) #sio.emit(topic, data=json.dumps(data), skip_sid=True)
#!/usr/bin/env python import eventlet from eventlet.green import urllib2 eventlet.monkey_patch(os=False, thread=False) urls = [ "http://www.sina.com.cn", "http://baidu.com", "http://163.com", ] def fetch(url): return urllib2.urlopen(url).read() pool = eventlet.GreenPool() for body in pool.imap(fetch, urls): print("got body", len(body))
#!/usr/bin/env python import eventlet eventlet.monkey_patch(socket=True) from flask import Flask, render_template, session, request, jsonify, url_for from flask_socketio import SocketIO, emit, join_room, leave_room, \ close_room, rooms, disconnect from celery import Celery #from webapp.blueprints.bptest2 import bptest2 #from webapp.blueprints.bptest2 import tasks socketio = SocketIO() CELERY_TASK_LIST = [ 'webapp.blueprints.bptest1.tasks', 'webapp.blueprints.bptest2.tasks', ] def create_celery_app(app=None): """ Create a new Celery object and tie together the Celery config to the app's config. Wrap all tasks in the context of the application. :param app: Flask app :return: Celery app """ app = app or create_app() celery = Celery(app.import_name, broker='redis://:devpassword@redis:6379/0',
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import base64 import copy import httplib import netaddr import threading import time import eventlet eventlet.monkey_patch(thread=True) from oslo.config import cfg from six.moves import queue as Queue from neutron.api.v2 import attributes from neutron.common import log as call_log from neutron import context from neutron.db.loadbalancer import loadbalancer_db as lb_db from neutron.extensions import loadbalancer from neutron.openstack.common import excutils from neutron.openstack.common import jsonutils from neutron.openstack.common import log as logging from neutron.plugins.common import constants from neutron.services.loadbalancer.drivers import abstract_driver from neutron.services.loadbalancer.drivers.radware import exceptions as r_exc