async def shutdown(self, fast=False):
if self.status == 'closed':
return
try:
future = self._shutdown(fast=fast)
await to_asyncio_future(future)
with ignoring(AttributeError):
future = self.cluster._close()
await to_asyncio_future(future)
self.cluster.status = 'closed'
finally:
BaseAsyncIOLoop.clear_current()
async def setup_after_connection(app, loop):
logging.info("after server start")
# configure tornado use asyncio's loop
ioloop = BaseAsyncIOLoop(loop)
logging.info("after ioloop")
# ioloop = asyncio.get_running_loop()
# init distributed client
# cluster = LocalCluster(asynchronous=True, scheduler_port=8786, nanny=False, n_workers=2,
# threads_per_worker=1)
logging.info("setting up dask client with scheduler {}".format(app.dask_scheduler))
if app.dask_scheduler is None:
app.client = await Client(asynchronous=True, nanny=False)
else:
app.client = await Client(address = app.dask_scheduler, asynchronous=True)
print(app.client)
logging.info("setup client")
app.epivizFileHandler = FileHandlerProcess(fileTime, MAXWORKER)
app.epivizFileHandler.client = app.client
for rec in app.epivizMeasurementsManager.get_measurements():
if rec.datasource == "files" or rec.datasource == "computed":
rec.fileHandler = app.epivizFileHandler
logging.info("FileHandler created")
logging.info("starting client")
async def setup(app, loop):
# configure tornado use asyncio's loop
ioloop = BaseAsyncIOLoop(loop)
# init distributed client
app.client = Client('tcp://localhost:8786', loop=ioloop, start=False)
await to_asyncio_future(app.client._start())
def test_run_jobs_should_turn_all_jobs_into_periodic_callbacks(event_loop):
scheduler = Scheduler(ioloop=BaseAsyncIOLoop(event_loop))
@scheduler.schedule(interval=3000)
async def scheduled():
pass
assert scheduler.jobs_count == 1
scheduler.run()
assert scheduler.running_jobs_count == 1
def __init__(self, *args, **kwargs):
if kwargs.get('set_as_default'):
raise Exception("AioClient instance can't be set as default")
loop = asyncio.get_event_loop()
ioloop = BaseAsyncIOLoop(loop)
super().__init__(*args,
loop=ioloop,
set_as_default=False,
asynchronous=True,
**kwargs)
async def test_stop_should_decrease_running_job_count(event_loop):
scheduler = Scheduler(ioloop=BaseAsyncIOLoop(event_loop))
@scheduler.schedule(interval=3000, name="test")
async def test_job():
pass
scheduler.run()
assert scheduler.running_jobs_count == 1
asyncio.sleep(1)
scheduler.stop_all()
assert scheduler.running_jobs_count == 0
async def test_after_run_job_job_should_be_run_for_once(event_loop):
scheduler = Scheduler(ioloop=BaseAsyncIOLoop(event_loop))
job = JobStub()
@scheduler.schedule(interval=3000)
async def scheduled():
await job.run()
scheduler.run()
await asyncio.sleep(1)
assert job.is_runned
assert job.run_count == 1
async def test_run_should_run_function_2_times_in_3_sec(event_loop):
#: First run(will be triggered at run) and scheduled second run.
scheduler = Scheduler(ioloop=BaseAsyncIOLoop(event_loop))
job = JobStub()
@scheduler.schedule(interval=2000)
async def scheduled():
await job.run()
scheduler.run()
await asyncio.sleep(3)
assert job.is_runned
assert job.run_count == 2
import asyncio
import uvloop
from tornado.ioloop import IOLoop
from tornado.platform.asyncio import BaseAsyncIOLoop
from apps.httpService import HttpService
if __name__ == '__main__':
# loop = asyncio.get_event_loop()
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) # 修改循环策略为uvloop
aioloop = asyncio.get_event_loop() # 获取aioloop循环事件
ioloop = BaseAsyncIOLoop(aioloop) # 使用aioloop创建ioloop
HttpService()
ioloop.start()
from bokeh.document import Document
from bokeh.plotting import curdoc, figure, show
import asyncio
from tornado.platform.asyncio import BaseAsyncIOLoop, AsyncIOMainLoop
from tornado.ioloop import IOLoop
doc = Document()
def my_radio_handler(new):
doc.title = str(new)
print("Radio button " + str(new) + " option selected.")
radio_button_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[])
radio_button_group.on_click(my_radio_handler)
doc.add_root(radio_button_group)
loop = asyncio.get_event_loop()
io_loop = BaseAsyncIOLoop(asyncio_loop=loop)
# io_loop = IOLoop._ioloop_for_asyncio[loop]
# io_loop = IOLoop.current()
# Open a session to keep our local document in sync with server
session = push_session(doc, session_id="123", io_loop=io_loop)
# Run forever (this is crucial to retrive callback's data)
session._connection._loop.spawn_callback(session._connection._next)
loop.run_forever()
print("hw")
def __init__(self, *args, **kwargs):
loop = asyncio.get_event_loop()
ioloop = BaseAsyncIOLoop(loop)
super().__init__(*args, loop=ioloop, asynchronous=True, **kwargs)
import asyncio
import uvloop
from tornado.platform.asyncio import BaseAsyncIOLoop
from apps.httpService import HttpService
if __name__ == '__main__':
loop = asyncio.get_event_loop()
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) # 修改循环策略为uvloop
aioloop = asyncio.get_event_loop() # 获取aioloop循环事件
ioloop = BaseAsyncIOLoop(aioloop) # 使用aioloop创建ioloop
HttpService(ioloop=ioloop, aioloop=aioloop)
print('mysql 服务启动')
# ioloop.current().start()
aioloop.run_forever()