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