Python tornado.ioloop.stop() Examples
The following are 30
code examples of tornado.ioloop.stop().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tornado.ioloop
, or try the search function
.
![](https://www.programcreek.com/common/static/images/search.png)
Example #1
Source File: ioloop.py From EventGhost with GNU General Public License v2.0 | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #2
Source File: service_subcommand.py From ClusterRunner with Apache License 2.0 | 6 votes |
def _start_application(self, application, port): # Note: No significant application logic should be executed before this point. The call to application.listen() # will raise an exception if another process is using the same port. We rely on this exception to force us to # exit if there are any port conflicts. try: # If SSL cert and key files are provided in configuration, ClusterRunner wil start with HTTPS protocol. # Otherwise ClusterRunner will start with HTTP protocol. server = HTTPServer(application, ssl_options=self._get_https_options()) server.listen(port, '0.0.0.0') except OSError: self._logger.error('Could not start application on port {}. Is port already in use?'.format(port)) sys.exit(1) ioloop = tornado.ioloop.IOLoop.instance() # add a teardown callback that will stop the tornado server stop_tornado_ioloop = functools.partial(ioloop.add_callback, callback=ioloop.stop) UnhandledExceptionHandler.singleton().add_teardown_callback(stop_tornado_ioloop) return ioloop
Example #3
Source File: ioloop.py From enaml-native with MIT License | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #4
Source File: init.py From RobotAIEngine with Apache License 2.0 | 6 votes |
def shutdown(ioloop, server): ''' 关闭server :param server: tornado.httpserver.HTTPServer ''' logging.info( "HTTP interpreter service will shutdown in %ss...", 1) server.stop() deadline = time.time() + 1 def stop_loop(): ''' 尝试关闭loop ''' now = time.time() if now < deadline and (ioloop._callbacks or ioloop._timeouts): ioloop.add_timeout(now + 1, stop_loop) else: # 处理完现有的 callback 和 timeout 后 ioloop.stop() logging.info('Shutdown!') stop_loop()
Example #5
Source File: ioloop.py From vnpy_crypto with MIT License | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #6
Source File: mainloop.py From honeything with GNU General Public License v3.0 | 6 votes |
def RunOnce(self, timeout=None): """Run the mainloop for exactly one iteration. Processes all events that occur during that iteration, including timeouts. Args: timeout: same meaning as in Start(). """ # TODO(apenwarr): timeout is effectively always 0 for now. Oops. r, w = os.pipe() try: os.write(w, 'x') self.ioloop.add_handler(r, lambda fd, events: self.ioloop.stop(), self.ioloop.READ) self.Start(timeout) finally: os.close(r) os.close(w) self.ioloop.remove_handler(r)
Example #7
Source File: ioloop.py From tornado-zh with MIT License | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #8
Source File: mainloop.py From honeything with GNU General Public License v3.0 | 6 votes |
def Start(self, timeout=None): """Run the mainloop repetitively until the program is finished. "Finished" means one of three things: no event handlers remain (unlikely), the timeout expires, or someone calls ioloop.stop(). Args: timeout: the time at which the loop will be forcibly stopped. Mostly useful in unit tests. None means no timeout; 0 means stop instantly. """ tmo = None if timeout is not None: self.loop_timeout = tmo = self.ioloop.add_timeout( datetime.timedelta(seconds=timeout), self._TimedOut) try: self.ioloop.start() finally: if tmo: self.ioloop.remove_timeout(tmo) self.loop_timeout = None
Example #9
Source File: ioloop.py From Carnets with BSD 3-Clause "New" or "Revised" License | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #10
Source File: ioloop.py From pySINDy with MIT License | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #11
Source File: ioloop.py From tornado-zh with MIT License | 6 votes |
def stop(self): """Stop the I/O loop. If the event loop is not currently running, the next call to `start()` will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ``ioloop.start()`` will return after ``async_method`` has run its callback, whether that callback was invoked before or after ``ioloop.start``. Note that even after `stop` has been called, the `IOLoop` is not completely stopped until `IOLoop.start` has also returned. Some work that was scheduled before the call to `stop` may still be run before the `IOLoop` shuts down. """ raise NotImplementedError()
Example #12
Source File: ioloop.py From pySINDy with MIT License | 5 votes |
def stop(self): self._running = False self._stopped = True self._waker.wake()
Example #13
Source File: backend_webagg.py From coffeegrindsize with MIT License | 5 votes |
def start(cls): if cls.started: return """ IOLoop.running() was removed as of Tornado 2.4; see for example https://groups.google.com/forum/#!topic/python-tornado/QLMzkpQBGOY Thus there is no correct way to check if the loop has already been launched. We may end up with two concurrently running loops in that unlucky case with all the expected consequences. """ ioloop = tornado.ioloop.IOLoop.instance() def shutdown(): ioloop.stop() print("Server is stopped") sys.stdout.flush() cls.started = False @contextmanager def catch_sigint(): old_handler = signal.signal( signal.SIGINT, lambda sig, frame: ioloop.add_callback_from_signal(shutdown)) try: yield finally: signal.signal(signal.SIGINT, old_handler) # Set the flag to True *before* blocking on ioloop.start() cls.started = True print("Press Ctrl+C to stop WebAgg server") sys.stdout.flush() with catch_sigint(): ioloop.start()
Example #14
Source File: mainloop.py From honeything with GNU General Public License v3.0 | 5 votes |
def _TimedOut(self): self.ioloop.stop() self.ioloop.remove_timeout(self.loop_timeout) self.loop_timeout = None
Example #15
Source File: ioloop.py From enaml-native with MIT License | 5 votes |
def close(self, all_fds=False): """Closes the `IOLoop`, freeing any resources used. If ``all_fds`` is true, all file descriptors registered on the IOLoop will be closed (not just the ones created by the `IOLoop` itself). Many applications will only use a single `IOLoop` that runs for the entire lifetime of the process. In that case closing the `IOLoop` is not necessary since everything will be cleaned up when the process exits. `IOLoop.close` is provided mainly for scenarios such as unit tests, which create and destroy a large number of ``IOLoops``. An `IOLoop` must be completely stopped before it can be closed. This means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must be allowed to return before attempting to call `IOLoop.close()`. Therefore the call to `close` will usually appear just after the call to `start` rather than near the call to `stop`. .. versionchanged:: 3.1 If the `IOLoop` implementation supports non-integer objects for "file descriptors", those objects will have their ``close`` method when ``all_fds`` is true. """ raise NotImplementedError()
Example #16
Source File: ioloop.py From enaml-native with MIT License | 5 votes |
def start(self): """Starts the I/O loop. The loop will run until one of the callbacks calls `stop()`, which will make the loop stop after the current event iteration completes. """ raise NotImplementedError()
Example #17
Source File: ioloop.py From enaml-native with MIT License | 5 votes |
def stop(self): self._running = False self._stopped = True self._waker.wake()
Example #18
Source File: ioloop.py From tornado-zh with MIT License | 5 votes |
def close(self, all_fds=False): """Closes the `IOLoop`, freeing any resources used. If ``all_fds`` is true, all file descriptors registered on the IOLoop will be closed (not just the ones created by the `IOLoop` itself). Many applications will only use a single `IOLoop` that runs for the entire lifetime of the process. In that case closing the `IOLoop` is not necessary since everything will be cleaned up when the process exits. `IOLoop.close` is provided mainly for scenarios such as unit tests, which create and destroy a large number of ``IOLoops``. An `IOLoop` must be completely stopped before it can be closed. This means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must be allowed to return before attempting to call `IOLoop.close()`. Therefore the call to `close` will usually appear just after the call to `start` rather than near the call to `stop`. .. versionchanged:: 3.1 If the `IOLoop` implementation supports non-integer objects for "file descriptors", those objects will have their ``close`` method when ``all_fds`` is true. """ raise NotImplementedError()
Example #19
Source File: web_gui_server.py From openhtf with Apache License 2.0 | 5 votes |
def __exit__(self, *unused_args): self.stop()
Example #20
Source File: web_gui_server.py From openhtf with Apache License 2.0 | 5 votes |
def stop(self): self.server.stop() ioloop = tornado.ioloop.IOLoop.instance() ioloop.add_timeout(time.time() + _SERVER_SHUTDOWN_BUFFER_S, ioloop.stop)
Example #21
Source File: ioloop.py From pySINDy with MIT License | 5 votes |
def start(self): """Starts the I/O loop. The loop will run until one of the callbacks calls `stop()`, which will make the loop stop after the current event iteration completes. """ raise NotImplementedError()
Example #22
Source File: backend_webagg.py From CogAlg with MIT License | 5 votes |
def start(cls): if cls.started: return """ IOLoop.running() was removed as of Tornado 2.4; see for example https://groups.google.com/forum/#!topic/python-tornado/QLMzkpQBGOY Thus there is no correct way to check if the loop has already been launched. We may end up with two concurrently running loops in that unlucky case with all the expected consequences. """ ioloop = tornado.ioloop.IOLoop.instance() def shutdown(): ioloop.stop() print("Server is stopped") sys.stdout.flush() cls.started = False @contextmanager def catch_sigint(): old_handler = signal.signal( signal.SIGINT, lambda sig, frame: ioloop.add_callback_from_signal(shutdown)) try: yield finally: signal.signal(signal.SIGINT, old_handler) # Set the flag to True *before* blocking on ioloop.start() cls.started = True print("Press Ctrl+C to stop WebAgg server") sys.stdout.flush() with catch_sigint(): ioloop.start()
Example #23
Source File: ioloop.py From EventGhost with GNU General Public License v2.0 | 5 votes |
def close(self, all_fds=False): """Closes the `IOLoop`, freeing any resources used. If ``all_fds`` is true, all file descriptors registered on the IOLoop will be closed (not just the ones created by the `IOLoop` itself). Many applications will only use a single `IOLoop` that runs for the entire lifetime of the process. In that case closing the `IOLoop` is not necessary since everything will be cleaned up when the process exits. `IOLoop.close` is provided mainly for scenarios such as unit tests, which create and destroy a large number of ``IOLoops``. An `IOLoop` must be completely stopped before it can be closed. This means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must be allowed to return before attempting to call `IOLoop.close()`. Therefore the call to `close` will usually appear just after the call to `start` rather than near the call to `stop`. .. versionchanged:: 3.1 If the `IOLoop` implementation supports non-integer objects for "file descriptors", those objects will have their ``close`` method when ``all_fds`` is true. """ raise NotImplementedError()
Example #24
Source File: ioloop.py From EventGhost with GNU General Public License v2.0 | 5 votes |
def start(self): """Starts the I/O loop. The loop will run until one of the callbacks calls `stop()`, which will make the loop stop after the current event iteration completes. """ raise NotImplementedError()
Example #25
Source File: ioloop.py From EventGhost with GNU General Public License v2.0 | 5 votes |
def stop(self): self._running = False self._stopped = True self._waker.wake()
Example #26
Source File: ioloop.py From Carnets with BSD 3-Clause "New" or "Revised" License | 5 votes |
def close(self, all_fds=False): """Closes the `IOLoop`, freeing any resources used. If ``all_fds`` is true, all file descriptors registered on the IOLoop will be closed (not just the ones created by the `IOLoop` itself). Many applications will only use a single `IOLoop` that runs for the entire lifetime of the process. In that case closing the `IOLoop` is not necessary since everything will be cleaned up when the process exits. `IOLoop.close` is provided mainly for scenarios such as unit tests, which create and destroy a large number of ``IOLoops``. An `IOLoop` must be completely stopped before it can be closed. This means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must be allowed to return before attempting to call `IOLoop.close()`. Therefore the call to `close` will usually appear just after the call to `start` rather than near the call to `stop`. .. versionchanged:: 3.1 If the `IOLoop` implementation supports non-integer objects for "file descriptors", those objects will have their ``close`` method when ``all_fds`` is true. """ raise NotImplementedError()
Example #27
Source File: ioloop.py From Carnets with BSD 3-Clause "New" or "Revised" License | 5 votes |
def start(self): """Starts the I/O loop. The loop will run until one of the callbacks calls `stop()`, which will make the loop stop after the current event iteration completes. """ raise NotImplementedError()
Example #28
Source File: ioloop.py From Carnets with BSD 3-Clause "New" or "Revised" License | 5 votes |
def stop(self): self._running = False self._stopped = True self._waker.wake()
Example #29
Source File: backend_webagg.py From twitter-stock-recommendation with MIT License | 5 votes |
def start(cls): if cls.started: return """ IOLoop.running() was removed as of Tornado 2.4; see for example https://groups.google.com/forum/#!topic/python-tornado/QLMzkpQBGOY Thus there is no correct way to check if the loop has already been launched. We may end up with two concurrently running loops in that unlucky case with all the expected consequences. """ ioloop = tornado.ioloop.IOLoop.instance() def shutdown(): ioloop.stop() print("Server is stopped") sys.stdout.flush() cls.started = False @contextmanager def catch_sigint(): old_handler = signal.signal( signal.SIGINT, lambda sig, frame: ioloop.add_callback_from_signal(shutdown)) try: yield finally: signal.signal(signal.SIGINT, old_handler) # Set the flag to True *before* blocking on ioloop.start() cls.started = True print("Press Ctrl+C to stop WebAgg server") sys.stdout.flush() with catch_sigint(): ioloop.start()
Example #30
Source File: __init__.py From bugbuzz-python with MIT License | 5 votes |
def stop(self): pass