def main(MASTER_ADDR, WORKER_ROUTER_ADDR, slave_addr, control_router_addr): global context global master_conn global worker_router global worker_manager global SLAVE_ADDR global CONTROL_ROUTER_ADDR SLAVE_ADDR = slave_addr CONTROL_ROUTER_ADDR = control_router_addr try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) context = Context() master_conn = MasterConnection(context, MASTER_ADDR) worker_router = WorkerRouter(context, WORKER_ROUTER_ADDR) worker_manager = WorkerManager() #loop.set_default_executor(ProcessPoolExecutor()) loop.run_until_complete(run_server()) except KeyboardInterrupt: print('\nFinished (interrupted)') sys.exit(0)
def main(): try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) loop.run_until_complete(run_server()) except KeyboardInterrupt: print('\nFinished (interrupted)') sys.exit(0)
def main(): args = sys.argv[1:] if len(args) != 0: sys.exit(__doc__) try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) loop.run_until_complete(run(loop)) except KeyboardInterrupt: print('\nFinished (interrupted)')
def main(slave_addr, serialized_data : bytes): try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) context = Context() loop.run_until_complete(run_worker(context, slave_addr, serialized_data)) except KeyboardInterrupt: print('\nFinished (interrupted)') sys.exit(0)
def main(): args = sys.argv[1:] if len(args) > 1: sys.exit(__doc__) zip_filter = sys.argv[1] if len(sys.argv) > 1 else "10001" try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) loop.run_until_complete(run(loop, zip_filter)) except KeyboardInterrupt: print('\nFinished (interrupted)')
def main(client_router_addr, slave_router_addr): try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) context = Context() loop.run_until_complete(run_master(context, client_router_addr, slave_router_addr)) except KeyboardInterrupt: print('\nFinished (interrupted)') sys.exit(0)
def start_asyncio_and_zmq(debug_asyncio=False): """ Init asyncio and ZMQ. Starts a daemon thread in which the asyncio loops run. :return: a ZMQ context and a Thread object (as a tuple) """ loop = ZMQEventLoop() asyncio.set_event_loop(loop) if debug_asyncio: loop.set_debug(True) zmq_context = Context() t = threading.Thread(target=_run_asyncio, args=(loop, zmq_context), daemon=True) t.start() return zmq_context, t
def main(): args = sys.argv[1:] if len(args) == 1: num_requests = int(args[0]) elif len(args) == 0: num_requests = 10 else: sys.exit(__doc__) try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) loop.run_until_complete(run(loop, num_requests)) except KeyboardInterrupt: print('\nFinished (interrupted)')
def main(): app = Sanic(__name__) app.blueprint(ACCOUNTS_BP, url_prefix='/accounts') app.blueprint(ASSETS_BP, url_prefix='/assets') # app.blueprint(AUTH_BP) # app.blueprint(ERRORS_BP) # app.blueprint(HOLDINGS_BP) # app.blueprint(OFFERS_BP) load_config(app) # open_connections(app) # app.run(host='0.0.0.0', port=8000, debug=True) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host=app.config.HOST, port=app.config.PORT, debug=True) loop = asyncio.get_event_loop() asyncio.ensure_future(server) asyncio.ensure_future(open_connections(app)) signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: close_connections(app) loop.stop()
def execute(self): self.set_log_config() self.loop = ZMQEventLoop() asyncio.set_event_loop(self.loop) self.connection = None try: self.connection = Connection(self.url) wrapped_registry = None self.start_server( self.host, self.port, self.connection, int(self.apiconfig.config.timeout), wrapped_registry, client_max_size=self.apiconfig.config.client_max_size) # pylint: disable=broad-except except Exception as e: LOGGER.exception(e) sys.exit(1) finally: if self.connection is not None: self.connection.close()
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop) connection = None try: opts = parse_args(sys.argv[1:]) init_console_logging(verbose_level=opts.verbose) url = opts.connect if "tcp://" not in url: url = "tcp://" + url connection = Connection(url) try: host, port = opts.bind.split(":") port = int(port) except ValueError: print("Unable to parse binding {}: Must be in the format" " host:port".format(opts.bind)) sys.exit(1) start_rest_api(host, port, connection) except Exception as err: # pylint: disable=broad-except LOGGER.exception(err) sys.exit(1) finally: if connection is not None: connection.close()
def main(): LOGGER.info('Starting Clinic Rest API server...') # CORS(app) app.blueprint(DOCTORS_BP) app.blueprint(PATIENTS_BP) app.blueprint(CLIENTS_BP) app.blueprint(CONSENT_BP) app.blueprint(EVALUATION_BP) load_config(app) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG, return_asyncio_server=True) loop = asyncio.get_event_loop() asyncio.ensure_future(open_connections(app)) asyncio.ensure_future(server) signal(SIGINT, lambda s, f: loop.close()) try: LOGGER.info('Clinic Rest API server starting') loop.run_forever() except KeyboardInterrupt: LOGGER.info('Clinic Rest API started interrupted') close_connections(app) loop.stop()
def main(): app = Sanic(__name__) app.blueprint(ACCOUNTS_BP) app.blueprint(RESOURCES_BP) app.blueprint(AUTH_BP) app.blueprint(ERRORS_BP) app.blueprint(ASSETS_BP) app.blueprint(OFFERS_BP) app.blueprint(TRANSFER_BP) load_config(app) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server( host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG) loop = asyncio.get_event_loop() asyncio.ensure_future(server) asyncio.ensure_future(open_connections(app)) signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: close_connections(app) loop.stop()
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop) try: opts = parse_args(sys.argv[1:]) init_console_logging(verbose_level=opts.verbose) validator_url = opts.connect if "tcp://" not in validator_url: validator_url = "tcp://" + validator_url messenger = Messenger(validator_url) try: host, port = opts.bind.split(":") port = int(port) except ValueError: print("Unable to parse binding {}: Must be in the format" " host:port".format(opts.bind)) sys.exit(1) start_rest_api(host, port, messenger) except Exception as err: # pylint: disable=broad-except LOGGER.exception(err) sys.exit(1) finally: messenger.close_validator_connection()
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop=loop) try: start_server('localhost', 8096) except Exception as err: LOGGER.exception(err) sys.exit(1)
def main(): args = sys.argv[1:] if len(args) < 1: sys.exit(__doc__) zipcodes = args try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) run(loop, zipcodes) except KeyboardInterrupt: print('\nFinished (interrupted)')
def main(): args = sys.argv[1:] if len(args) != 2: sys.exit(__doc__) try: ident = args[0] num_workers = int(args[1]) loop = ZMQEventLoop() asyncio.set_event_loop(loop) run(loop, ident, num_workers) except KeyboardInterrupt: print('\nFinished (interrupted)')
def main(): args = sys.argv[1:] if len(args) != 0: sys.exit(__doc__) try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) run(loop) print('(main) exiting') except KeyboardInterrupt: print('\nFinished (interrupted)') sys.exit(0)
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop) connection = None try: opts = parse_args(sys.argv[1:]) opts_config = RestApiConfig( bind=opts.bind, connect=opts.connect, timeout=opts.timeout) rest_api_config = load_rest_api_config(opts_config) url = None if "tcp://" not in rest_api_config.connect: url = "tcp://" + rest_api_config.connect else: url = rest_api_config.connect connection = Connection(url) log_config = get_log_config(filename="rest_api_log_config.toml") # If no toml, try loading yaml if log_config is None: log_config = get_log_config(filename="rest_api_log_config.yaml") if log_config is not None: log_configuration(log_config=log_config) else: log_dir = get_log_dir() log_configuration(log_dir=log_dir, name="rest_api") init_console_logging(verbose_level=opts.verbose) try: host, port = rest_api_config.bind[0].split(":") port = int(port) except ValueError as e: print("Unable to parse binding {}: Must be in the format" " host:port".format(rest_api_config.bind[0])) sys.exit(1) start_rest_api( host, port, connection, int(rest_api_config.timeout)) # pylint: disable=broad-except except Exception as e: print("Error: {}".format(e), file=sys.stderr) finally: if connection is not None: connection.close()
def main(): LOGGER.warning("## in api ##") opts = parse_args(sys.argv[1:]) init_logger(opts.verbose) try: host, port = opts.bind.split(":") port = int(port) except ValueError: print("Unable to parse binding {}: Must be in the format" " host:port".format(opts.bind)) sys.exit(1) loop = ZMQEventLoop() asyncio.set_event_loop(loop) try: DatabaseImp.initialize(opts.uri) start_rest_api(host, port, opts, loop) except KeyboardInterrupt: pass finally: print("Closing Loop") loop.close()
def main(): app = Sanic(__name__) app.blueprint(AUTH_BP) app.blueprint(BLOCKS_BP) app.blueprint(CHATBOT_BP) app.blueprint(ERRORS_BP) app.blueprint(PROPOSALS_BP) app.blueprint(ROLES_BP) app.blueprint(TASKS_BP) app.blueprint(USERS_BP) app.blueprint(APP_BP) @app.middleware("request") async def handle_options(request): # pylint: disable=unused-variable if request.method == "OPTIONS": return text( "ok", headers={ "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS", "Access-Control-Allow-Headers": "Content-Type, Authorization", }, ) @app.middleware("response") def allow_cors(request, response): # pylint: disable=unused-variable response.headers["Access-Control-Allow-Origin"] = "*" response.headers[ "Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS" response.headers[ "Access-Control-Allow-Headers"] = "Content-Type, Authorization" load_config(app) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG) loop = asyncio.get_event_loop() asyncio.ensure_future(server) asyncio.ensure_future(open_connections(app)) signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: close_connections(app) loop.stop()
def main(): """RBAC API server main event loop""" app = Sanic(__name__) app.blueprint(AUTH_BP) app.blueprint(BLOCKS_BP) app.blueprint(CHATBOT_BP) app.blueprint(ERRORS_BP) app.blueprint(FEED_BP) app.blueprint(PACKS_BP) app.blueprint(PROPOSALS_BP) app.blueprint(ROLES_BP) app.blueprint(SEARCH_BP) app.blueprint(SWAGGER_BP) app.blueprint(TASKS_BP) app.blueprint(USERS_BP) app.blueprint(WEBHOOKS_BP) app.blueprint(APP_BP) load_config(app) CORS( app, automatic_options=True, supports_credentials=True, resources={ r"/api/*": { "origins": "*" }, r"/webhooks/*": { "origins": "*" } }, ) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host="0.0.0.0", port=app.config.PORT, debug=False, access_log=False) loop = asyncio.get_event_loop() asyncio.ensure_future(server) asyncio.ensure_future(init(app, loop)) signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: finish(app) loop.stop()
def main(): """main function""" printdbg('(main) starting') args = sys.argv[1:] if len(args) != 0: sys.exit(__doc__) try: loop = ZMQEventLoop() asyncio.set_event_loop(loop) printdbg('(main) before starting run()') run(loop) printdbg('(main) after starting run()') except KeyboardInterrupt: print('\nFinished (interrupted)')
def main(): app = Sanic(__name__) app.blueprint(AUTH_BP) app.blueprint(BLOCKS_BP) app.blueprint(ERRORS_BP) app.blueprint(PROPOSALS_BP) app.blueprint(ROLES_BP) app.blueprint(TASKS_BP) app.blueprint(USERS_BP) app.blueprint(APP_BP) @app.middleware('request') async def handle_options(request): # pylint: disable=unused-variable if request.method == 'OPTIONS': return text('ok', headers={ 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-XSRF-TOKEN' }) @app.middleware('response') def allow_cors(request, response): # pylint: disable=unused-variable response.headers['Access-Control-Allow-Origin'] = '*' response.headers['Access-Control-Allow-Methods'] =\ 'GET, POST, PUT, PATCH, DELETE, OPTIONS' response.headers['Access-Control-Allow-Headers'] =\ 'Content-Type, Authorization, X-XSRF-TOKEN' load_config(app) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG) loop = asyncio.get_event_loop() asyncio.ensure_future(server) asyncio.ensure_future(open_connections(app)) signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: close_connections(app) loop.stop()
def start_rest_api(args, host, port, connection=None, timeout=300, registry=None, client_max_size=10485760): """Builds the web app, adds route handlers, and finally starts the app. """ global global_args global_args = args loop = ZMQEventLoop() asyncio.set_event_loop(loop) init_console_logging() LOGGER.info('Starting CLINET REST API on %s:%s', host, port) loop = asyncio.get_event_loop() # connection.open() app = web.Application(loop=loop, client_max_size=client_max_size) # app.on_cleanup.append(lambda app: connection.close()) # Add routes to the web app # handler = RouteHandler(loop, connection, timeout, registry) # app.router.add_post('/batches', handler.submit_batches) # app.router.add_get('/batch_statuses', handler.list_statuses) app.router.add_route('*', '/register', register_pubkey) app.router.add_route('*', '/user', show_user) app.router.add_route('*', '/admin/list', list_need_approve) app.router.add_route('*', '/admin/approve', approve_public_key) app.router.add_route('*', '/will/create', create_will) app.router.add_route('*', '/will', show_will) app.router.add_route('*', '/will/list', show_will_list) app.router.add_route('*', '/will/witness_sign', witness_sign) app.router.add_route('*', '/generate_key', generate_key) web.run_app(app, host=host, port=port, access_log=LOGGER, access_log_format='%r: %s status, %b size, in %Tf s')
def main(): print() print("__Hoang Thanh Lam__") print() loop = ZMQEventLoop() asyncio.set_event_loop(loop) try: opts = parse_args(sys.argv[1:]) try: host, port = opts.bind.split(":") port = int(port) except ValueError: print("Unable to parse binding {}: Must be in the format" " host:port".format(opts.bind)) sys.exit(1) start_server(host, port) except Exception as err: LOGGER.exception(err) sys.exit(1)
def main(): app = Sanic(__name__) app.blueprint(AUTH_BP) app.blueprint(BLOCKS_BP) app.blueprint(CHATBOT_BP) app.blueprint(ERRORS_BP) app.blueprint(PROPOSALS_BP) app.blueprint(ROLES_BP) app.blueprint(TASKS_BP) app.blueprint(USERS_BP) app.blueprint(WEBHOOKS_BP) app.blueprint(APP_BP) CORS( app, automatic_options=True, supports_credentials=True, resources={ r"/api/*": {"origins": CLIENT_HOST + ":" + CLIENT_PORT}, r"/webhooks/*": {"origins": "*"}, }, ) load_config(app) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server( host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG ) loop = asyncio.get_event_loop() asyncio.ensure_future(server) asyncio.ensure_future(init(app, loop)) signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: finish(app) loop.stop()
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop) try: opts = parse_args(sys.argv[1:]) init_console_logging(verbose_level=opts.verbose) validator_url = opts.connect if 'tcp://' not in validator_url: validator_url = 'tcp://' + validator_url messenger = Messenger(validator_url) database = Database( opts.db_host, opts.db_port, opts.db_name, opts.db_user, opts.db_password, loop) try: host, port = opts.bind.split(':') port = int(port) except ValueError: print(f'Unable to parse binding {opts.bind}: Must be in the format host:port') sys.exit(1) init_api(messenger, database) except Exception as err: # pylint: disable=broad-except # LOGGER.exception(err) fprint('err exe: ') fprint(err) sys.exit(1) finally: # database.disconnect() messenger.close_validator_connection()
def main(): LOGGER.info('Starting Hospital Rest API server...') # CORS(app) app.blueprint(HOSPITALS_BP) app.blueprint(INVESTIGATORS_BP) app.blueprint(PATIENTS_BP) app.blueprint(EHRS_BP) # app.blueprint(CLAIM_DETAILS_BP) # app.blueprint(LAB_TESTS_BP) # app.blueprint(PULSE_BP) app.blueprint(CLIENTS_BP) # app.blueprint(LABS_BP) # app.blueprint(INSURANCES_BP) # app.blueprint(CONTRACT_BP) # app.blueprint(PAYMENT_BP) # app.blueprint(OFFERS_BP) load_config(app) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG, return_asyncio_server=True) loop = asyncio.get_event_loop() asyncio.ensure_future(open_connections(app)) asyncio.ensure_future(server) signal(SIGINT, lambda s, f: loop.close()) try: LOGGER.info('Hospital Rest API server starting') loop.run_forever() except KeyboardInterrupt: LOGGER.info('Hospital Rest API started interrupted') close_connections(app) loop.stop()
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop) try: opts = parse_args(sys.argv[1:]) init_console_logging(verbose_level=opts.verbose) validator_url = opts.connect if "tcp://" not in validator_url: validator_url = "tcp://" + validator_url database = Database(opts.db_host, opts.db_port, opts.db_name, opts.db_user, opts.db_password, loop) messenger = Messenger(validator_url, database) try: host, port = opts.bind.split(":") port = int(port) except ValueError: print("Unable to parse binding {}: Must be in the format" " host:port".format(opts.bind)) sys.exit(1) dotenv_path = join(dirname(__file__), '.env') load_dotenv(dotenv_path) start_rest_api(host, port, messenger, database) except Exception as err: # pylint: disable=broad-except LOGGER.exception(err) sys.exit(1) finally: database.disconnect() messenger.close_validator_connection()
def main(): loop = ZMQEventLoop() asyncio.set_event_loop(loop) connection = None try: opts = parse_args(sys.argv[1:]) opts_config = RestApiConfig(bind=opts.bind, connect=opts.connect, timeout=opts.timeout, opentsdb_url=opts.opentsdb_url, opentsdb_db=opts.opentsdb_db) rest_api_config = load_rest_api_config(opts_config) url = None if "tcp://" not in rest_api_config.connect: url = "tcp://" + rest_api_config.connect else: url = rest_api_config.connect connection = Connection(url) log_config = get_log_config(filename="rest_api_log_config.toml") # If no toml, try loading yaml if log_config is None: log_config = get_log_config(filename="rest_api_log_config.yaml") if log_config is not None: log_configuration(log_config=log_config) else: log_dir = get_log_dir() log_configuration(log_dir=log_dir, name="rest_api") init_console_logging(verbose_level=opts.verbose) try: host, port = rest_api_config.bind[0].split(":") port = int(port) except ValueError as e: print("Unable to parse binding {}: Must be in the format" " host:port".format(rest_api_config.bind[0])) sys.exit(1) wrapped_registry = None if rest_api_config.opentsdb_url: LOGGER.info("Adding metrics reporter: url=%s, db=%s", rest_api_config.opentsdb_url, rest_api_config.opentsdb_db) url = urlparse(rest_api_config.opentsdb_url) proto, db_server, db_port, = url.scheme, url.hostname, url.port registry = MetricsRegistry() wrapped_registry = MetricsRegistryWrapper(registry) reporter = InfluxReporter( registry=registry, reporting_interval=10, database=rest_api_config.opentsdb_db, prefix="sawtooth_rest_api", port=db_port, protocol=proto, server=db_server, username=rest_api_config.opentsdb_username, password=rest_api_config.opentsdb_password) reporter.start() start_rest_api(host, port, connection, int(rest_api_config.timeout), wrapped_registry) # pylint: disable=broad-except except Exception as e: LOGGER.exception(e) sys.exit(1) finally: if connection is not None: connection.close()
ws.send_bytes(message[-1]) # CLI def init_function(argv): rpc = RPC() app = web.Application() # Pass the websocket handler to the router, not the rpc method... app.router.add_route('GET', '/', rpc.websocket_handler) return app async def init(loop): rpc = RPC(loop=loop) app = web.Application(loop=loop) app.router.add_route('GET', '/', rpc.websocket_handler) handler = app.make_handler() srv = await loop.create_server(handler, '127.0.0.1', 8080) print('Server started at http://127.0.0.1:8080') return srv, handler if __name__ == '__main__': loop = ZMQEventLoop() asyncio.set_event_loop(loop) srv, handler = loop.run_until_complete(init(loop)) try: loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(handler.finish_connections())
"""Example using zmq with asyncio coroutines""" # Copyright (c) PyZMQ Developers. # This example is in the public domain (CC-0) import time import zmq from zmq.asyncio import Context, Poller, ZMQEventLoop import asyncio url = 'tcp://127.0.0.1:5555' loop = ZMQEventLoop() asyncio.set_event_loop(loop) ctx = Context() @asyncio.coroutine def ping(): """print dots to indicate idleness""" while True: yield from asyncio.sleep(0.5) print('.') @asyncio.coroutine def receiver(): """receive messages with polling""" pull = ctx.socket(zmq.PULL) pull.connect(url) poller = Poller() poller.register(pull, zmq.POLLIN)
if __name__ == '__main__': cfg_rpc = load_toml_with_defaults( '/config/remme-rpc-api.toml')['remme']['rpc_api'] cfg_ws = load_toml_with_defaults( '/config/remme-client-config.toml')['remme']['client'] setup_logging('remme-rpc-api') parser = argparse.ArgumentParser() parser.add_argument('--port', type=int, default=cfg_rpc["port"]) parser.add_argument('--bind', default=cfg_rpc["bind"]) arguments = parser.parse_args() loop = ZMQEventLoop() asyncio.set_event_loop(loop) app = web.Application(loop=loop) cors_config = cfg_rpc["cors"] # enable CORS if isinstance(cors_config["allow_origin"], str): cors_config["allow_origin"] = [cors_config["allow_origin"]] cors = aiohttp_cors.setup( app, defaults={ ao: aiohttp_cors.ResourceOptions( allow_methods=cors_config["allow_methods"], max_age=cors_config["max_age"], allow_credentials=cors_config["allow_credentials"],
def _worker_main(id, slave_addr, task): print("_worker_main") import zmq from zmq.asyncio import Context, ZMQEventLoop import asyncio from ..common.task import SleepTaskResult from .task import SleepTask def _resolve_msg(msg): print(msg) #addr = msg[0] #assert msg[1] == b"" header = msg[0] assert msg[1] == b"" body = msg[2] return header, body def _dispatch_msg(header, body = b""): async def _dispatch_msg(msg): await socket.send_multipart(msg) msg = [id.encode(encoding='utf-8'), b'', header, b'', body] asyncio.ensure_future(_dispatch_msg(msg)) def __dispatch_msg(header, body=b""): def _dispatch_msg(msg): socket.send_multipart(msg) msg = [id.encode(encoding='utf-8'), b'', header, b'', body] _dispatch_msg(msg) def _process_sleep_task(task): async def __process_sleep_task(task): await asyncio.sleep(task.job.seconds) task.result = SleepTaskResult("Sleep " + str(task.job.seconds) + "By " + id) _dispatch_msg(b"TaskFinish", task.result.to_bytes()) asyncio.ensure_future(__process_sleep_task(task)) async def _run_worker(): _dispatch_msg(b"TaskStart") if isinstance(task, SleepTask): _process_sleep_task(task) else: raise ValueError("Invalid Task Type.") while True: msg = await socket.recv_multipart() header, body = _resolve_msg(msg) # some codes will be filled later. break print("[Worker {0}] I'm created!".format(id)) loop = ZMQEventLoop() asyncio.set_event_loop(loop) context = Context() socket = context.socket(zmq.DEALER) socket.connect(slave_addr) """ policy = asyncio.get_event_loop_policy() policy.set_event_loop(policy.new_event_loop()) loop = asyncio.get_event_loop() """ loop.run_until_complete(_run_worker())
if (yield from client.poll(1000)): msg = yield from client.recv() if msg == b"Hello": logging.info("Ironhouse test OK") else: logging.error("Ironhouse test FAIL") # close sockets server.close() client.close() # stop auth task auth.stop() if __name__ == '__main__': if zmq.zmq_version_info() < (4,0): raise RuntimeError("Security is not supported in libzmq version < 4.0. libzmq version {0}".format(zmq.zmq_version())) if '-v' in sys.argv: level = logging.DEBUG else: level = logging.INFO logging.basicConfig(level=level, format="[%(levelname)s] %(message)s") loop = ZMQEventLoop() asyncio.set_event_loop(loop) loop.run_until_complete(run()) loop.close()
def setUp(self): self.loop = ZMQEventLoop() asyncio.set_event_loop(self.loop) self.worker = WorkerManagement() self.worker.loop = self.loop self.worker.manager = PluginManager()
def main(): #app.blueprint(ACCOUNTS_BP) #app.blueprint(ERRORS_BP) #app.blueprint(ASSETS_BP) load_config(app) app.blueprint(ACCOUNTS_BP) app.blueprint(ERRORS_BP) app.blueprint(ASSETS_BP) #app.blueprint(USER_ACCOUNTS_BP) for handler, (rule, router) in app.router.routes_names.items(): print(rule) zmq = ZMQEventLoop() asyncio.set_event_loop(zmq) server = app.create_server(host=app.config.HOST, port=app.config.PORT, debug=app.config.DEBUG, access_log=True) loop = asyncio.get_event_loop() ##not wait for the server to strat, this will return a future object asyncio.ensure_future(server) app.config.DB = loop.run_until_complete(open_connections(app)) ##future.add_done_callback(functools.partial(db_callback, app)) #task = asyncio.ensure_future(from_mnemonic(app.config.GOAPI_URL, #app.config.ADMIN_MNEMONIC)) #task.add_done_callback(functools.partial(mstr_mnemic_chk_calbck, app)) loop.run_until_complete(master_mnemonic(app)) admin = loop.run_until_complete( find_on_key( app, "email", app.config.ADMIN_EMAIL, )) ##if ADMIN data is not present in the users_table then insert if not admin: admin = loop.run_until_complete(new_account(app, \ pancard=app.config.ADMIN_PANCARD, phone_number=app.config.ADMIN_PHONE_NUMBER, email=app.config.ADMIN_EMAIL, \ role="ADMIN", gst_number=app.config.ADMIN_GST_NUMBER, tan_number=app.config.ADMIN_TAN_NUMBER, org_name=app.config.ADMIN_ORG_NAME)) mnemonic, admin = loop.run_until_complete( set_password(app, account=admin, password=app.config.ADMIN_PASSWORD)) ##since ADMIN not going to have a create_account transaction on ##blockchain, its fine to set its claimed to True admin.update({"claimed": True}) admin.update({"parent_pub": None, "parent_idx": 0}) logging.info(app.config) loop.run_until_complete(submit_admin_account(app, admin)) else: logging.info("Admin found in the Database") signal(SIGINT, lambda s, f: loop.close()) try: loop.run_forever() except KeyboardInterrupt: close_connections(app) loop.stop()
class TestWorker(TestCase): @patch('alamo_worker.manage.WorkerManagement.__init__', MagicMock(return_value=None)) def setUp(self): self.loop = ZMQEventLoop() asyncio.set_event_loop(self.loop) self.worker = WorkerManagement() self.worker.loop = self.loop self.worker.manager = PluginManager() def tearDown(self): self.loop.close() asyncio.set_event_loop(None) @asyncio.coroutine def mark_soft_exit(self): self.worker.soft_exit = True def get_future(self, result): """Wrap `result` as Future object.""" fut = asyncio.Future(loop=self.loop) fut.set_result(result) return fut @patch('alamo_worker.manage.WorkerManagement.__init__', MagicMock(return_value=None)) @patch('alamo_worker.manage.WorkerManagement.close') def test_worker_manager_as_context_manager(self, close): with WorkerManagement(): pass self.assertTrue(close.called) @patch('alamo_worker.manage.PluginManager.load') def test_load_plugins_with_correct_plugin_list(self, load_mock): self.worker._load_plugins() self.assertTrue(load_mock.called) @patch('alamo_worker.manage.Queue') @patch('alamo_worker.manage.Sentinel.master_for') def test_connect_to_queue(self, zmq_mock, master_for): self.worker._connect_to_queue() self.assertTrue(master_for.called) self.assertTrue(zmq_mock.called) @patch('alamo_worker.manage.WorkerManagement.__init__', Mock()) @patch('alamo_worker.manage.Session.get') def test_get_environments(self, session_mock): mock_response = MagicMock(status_code=200) mock_response.raise_for_status.return_value = None mock_response.json.return_value = ENV_CONF session_mock.return_value = mock_response envs = self.worker._get_environments() self.assertEqual(envs, ENV_CONF) def test_send_method(self): self.worker.queue = MagicMock() self.worker.send('foo') self.worker.queue.enqueue.assert_called_with( 'alamo_alerter.job.analyze', args=('foo',), result_ttl=60 ) @patch('alamo_worker.manage.SchedulerConnection') def test_worker_open_method(self, mocked): mocked.return_value = MagicMock() self.worker.scheduler_pool = [] self.worker.open() self.assertEqual(len(self.worker.scheduler_pool), 1) def test_worker_close_method(self): scheduler = MagicMock() self.worker.scheduler_pool = [scheduler] self.worker.close() scheduler.close.assert_called_once_with() @unpack @data((False, 1), (True, 2)) def test_worker_generate_futures_method(self, monitor, expected): scheduler = MagicMock() self.worker.scheduler_pool = [scheduler] with override_settings(SCHEDULER_MONITOR=monitor): futures = [f for f in self.worker.generate_futures()] self.assertEqual(len(futures), expected) def test_worker_wait_and_kill_method(self): self.loop.run_until_complete(self.worker.wait_and_kill('SIGINT')) self.assertTrue(self.worker.soft_exit) @unpack @data( (None, None, False, False), ({'id': 999, 'type': 'graphite'}, dict(id=999), True, True), ({'id': 999, 'type': 'graphite'}, None, False, True), ) @patch('alamo_worker.manage.PluginManager.dispatch') @patch('alamo_worker.manage.WorkerManagement.send') def test_worker_receiver_method(self, event, dispatch_res, send_called, dispatch_called, send, dispatch): @asyncio.coroutine def _dispatch(*args, **kwargs): return dispatch_res dispatch.side_effect = _dispatch send._is_coroutine = False scheduler = MagicMock() scheduler.receive.side_effect = [ self.get_future(event), self.mark_soft_exit() ] self.worker.scheduler_pool = [scheduler] future = asyncio.async(self.worker.receiver(scheduler)) self.loop.run_until_complete(future) self.assertTrue(future.done()) self.assertEqual(send.called, send_called) self.assertEqual(dispatch.called, dispatch_called) @unpack @data( (True, dict(event=1), False, True), (True, dict(event=EVENT_DISCONNECTED), True, True), (True, dict(event=EVENT_MONITOR_STOPPED), False, True), (False, dict(event=1), False, False) ) @patch('alamo_worker.manage.logger') def test_worker_monitor_method(self, monitor, event, warn, info, logger): scheduler = MagicMock() scheduler.receive_event.side_effect = [ self.get_future(event), self.mark_soft_exit() ] self.worker.scheduler_pool = [scheduler] future = asyncio.async(self.worker.monitor(scheduler)) with override_settings(SCHEDULER_MONITOR=monitor): self.loop.run_until_complete(future) self.assertTrue(future.done()) self.assertEqual(logger.warning.called, warn) self.assertEqual(logger.info.called, info) @patch('alamo_worker.manage.WorkerManagement.generate_futures') def test_worker_execute_method(self, futures): futures.return_value = [self.mark_soft_exit()] self.worker.execute() self.assertTrue(self.loop.is_closed())
#!/usr/bin/env python
for key, value in self._cache.items(): self.send_multipart(key, self._cache[value]) elif _topic in self._cache: self.send_multipart( _topic, self._cache[_topic]) def test_md_send_multipart(): _server = MdPubServer(9988) _server.send_multipart("a", {"key":["a", "b", "c"], "data": "nihao"}) time.sleep(0.5) _server.send_multipart("b", {"key": ["a", "b", "c"], "data": "nihao"}) time.sleep(0.5) _server.send_multipart("c", {"key": ["a", "b", "c"], "data": "nihao"}) time.sleep(0.5) if __name__ == '__main__': _server = MdPubServer(9988) loop = ZMQEventLoop() asyncio.set_event_loop(loop) lvm_task = loop.create_task(_server.lvm()) _server.send_multipart("a", {"key":["a", "b", "c"], "data": "nihao"}) time.sleep(0.5) _server.send_multipart("b", {"key": ["a", "b", "c"], "data": "nihao"}) time.sleep(0.5) _server.send_multipart("c", {"key": ["a", "b", "c"], "data": "nihao"}) time.sleep(0.5) loop.run_until_complete(asyncio.wait([lvm_task]))