Python IOLoop.instance方法代码示例

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
    def run(self):
        # 
        # 启动 Tornado HTTP server。
        # 
        # 当 DEBUG = False 时，启动多进程模式。
        # 当 DEBUG = True 时，修改的模块自动重载。
        # 
        from os import getpid
        from tornado.httpserver import HTTPServer
        from tornado.ioloop import IOLoop

        app = Application(self._get_handlers(), **self._get_settings())
        server = HTTPServer(app)
        port = settings.PORT

        if settings.DEBUG:
            server.listen(port)
            IOLoop.instance().start()
        else:
            # 多进程模式
            server.bind(port)
            server.start(0)
            print " * Sub Process: {0}".format(getpid())

        IOLoop.instance().start()            

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def test_send_email_single_blacklisted_domain(smtp_sendmail, options):
    options = add_options(options)

    func = partial(accounts.utils.send_email, '[email protected]', 'test subject', 'test message')
    IOLoop.instance().run_sync(func)

    assert not smtp_sendmail.called

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def main() -> None:
    '''Runs server'''

    # Parse options
    define('production',
               default = False,
               help = 'run in production mode',
               type = bool)
    options.parse_command_line()

    # Set server name
    pname = settings.process_name if settings.process_name else None
    if pname:
        setproctitle(pname)

    # Register IRC server
    server = IRCServer(settings = ircdsettings)
    for address, port in ircdsettings['listen']:
        server.listen(port, address = address)

    # Start profiling
    if settings.profiling:
        import yappi
        yappi.start()

    # Setup autoreload
    autoreload.start()

    # Run application
    IOLoop.instance().start()

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def main():
  """ Main. """

  logging_level = logging.INFO
  if hermes_constants.DEBUG:
    logging_level = logging.DEBUG
  logging.getLogger().setLevel(logging_level)

  signal.signal(signal.SIGTERM, signal_handler)
  signal.signal(signal.SIGINT, signal_handler)

  parse_command_line()

  app = tornado.web.Application([
    (MainHandler.PATH, MainHandler),
    (TaskHandler.PATH, TaskHandler),
  ], debug=False)

  try:
    app.listen(options.port)
  except socket.error:
    logging.error("ERROR on Hermes initialization: Port {0} already in use.".
      format(options.port))
    shutdown()
    return

  logging.info("Hermes is up and listening on port: {0}.".
    format(options.port))

  # Start loop for accepting http requests.
  IOLoop.instance().start()

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
	def run(self):
		# Global as I can't work out a way to get it into PrinterStateConnection
		global printer
		global gcodeManager

		from tornado.wsgi import WSGIContainer
		from tornado.httpserver import HTTPServer
		from tornado.ioloop import IOLoop
		from tornado.web import Application, FallbackHandler

		# first initialize the settings singleton and make sure it uses given configfile and basedir if available
		self._initSettings(self._configfile, self._basedir)

		# then initialize logging
		self._initLogging(self._debug)

		gcodeManager = gcodefiles.GcodeManager()
		printer = Printer(gcodeManager)

		if self._host is None:
			self._host = settings().get(["server", "host"])
		if self._port is None:
			self._port = settings().getInt(["server", "port"])

		logging.getLogger(__name__).info("Listening on http://%s:%d" % (self._host, self._port))
		app.debug = self._debug

		self._router = tornadio2.TornadioRouter(PrinterStateConnection)

		self._tornado_app = Application(self._router.urls + [
			(".*", FallbackHandler, {"fallback": WSGIContainer(app)})
		])
		self._server = HTTPServer(self._tornado_app)
		self._server.listen(self._port, address=self._host)
		IOLoop.instance().start()

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def main():
    parser = OptionParser()
    parser.add_option('-p', '--port', type='int', default=11001,
                      help='Port to serve from (default: 11001)')
    parser.add_option('-u', '--user', type='string', default=None,
                      help='Only track a single user')
    parser.add_option('--constraint', type='string', default=None,
                      help='HTCondor constraint expression')
    parser.add_option('--delay', type='int', default=300,
                      help='delay between calls to condor_q (default: 300 seconds)')
    parser.add_option('--debug', action='store_true', default=False,
                      help='Enable debug logging')
    (options, args) = parser.parse_args()

    if options.debug:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.INFO)

    if options.delay < 0 or options.delay > 1000:
        raise Exception('delay out of range')

    cfg = {'options':options, 'condor_q':False, 'state':[], 'monitoring':{}}

    # load condor_q
    IOLoop.instance().call_later(5, partial(condor_q_helper, cfg))

    # setup server
    s = server(cfg)
    s.start()

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
	def on_refresh_complete(cls, response, id, callback):
		"""Callback for request to get a new access token based on refresh token."""

		if response.code in (400, 401):

			if 'invalid_grant' in response.body:
				# Our refresh token is invalid, which means that we don't have
				# permission to access this user's content anymore. Forget them.
				Cache.delete(cls.auth_cache_key_template % id)
				Cache.delete(cls.profile_cache_key_template % id)
				TokenIdMapping.remove_id(id)
				logging.error("Access was revoked for %s; cached data deleted.", id)

			logging.error("HTTP %s while trying to refresh access token for %s.", response.code, id)
			return IOLoop.instance().add_callback(lambda: callback(None))

		elif response.code != 200:
			logging.error("Non-200 response to refresh token request (%s, id=%s): %r" % (response.code, id, response.body))
			return IOLoop.instance().add_callback(lambda: callback(None))

		results = json.loads(response.body)

		# sanity check
		if results['token_type'] != "Bearer":
			logging.error('Unknown token type received: %s' % results['token_type'])
			return IOLoop.instance().add_callback(lambda: callback(None))

		token = results['access_token']
		Cache.set(cls.auth_cache_key_template % id, token, time=results['expires_in'])

		IOLoop.instance().add_callback(lambda: callback(token))

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def run_tornado(addr, port, *args, **kwargs):
    """
    Starts the tornado webserver as wsgi server for OpenSlides.

    It runs in one thread.
    """
    # Save the port and the addr in a global var
    global RUNNING_HOST, RUNNING_PORT
    RUNNING_HOST = addr
    RUNNING_PORT = port

    # Don't try to read the command line args from openslides
    parse_command_line(args=[])

    # Setup WSGIContainer
    app = WSGIContainer(get_wsgi_application())

    # Collect urls
    sock_js_router = SockJSRouter(OpenSlidesSockJSConnection, '/sockjs')
    other_urls = [
        (r'%s(.*)' % settings.STATIC_URL, DjangoStaticFileHandler),
        (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}),
        ('.*', FallbackHandler, dict(fallback=app))]

    # Start the application
    debug = settings.DEBUG
    tornado_app = Application(sock_js_router.urls + other_urls, autoreload=debug, debug=debug)
    server = HTTPServer(tornado_app)
    server.listen(port=port, address=addr)
    IOLoop.instance().start()

    # Reset the global vars
    RUNNING_HOST = None
    RUNNING_PORT = None

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def main():
    application = Application([
        (r"/", MainHandler),
        (r"/login", LoginHandler),
        (r"/logout", LogoutHandler),
        (r"/events", EventHandler),
        (r"/translations/([A-Za-z0-9_]+)/([A-Za-z0-9_]+)/([A-Za-z0-9_]+)", TranslationHandler),
        (r"/translations/([A-Za-z0-9_]+)/([A-Za-z0-9_]+)/([A-Za-z0-9_]+)/button", ButtonHandler),
        (r"/selections/([A-Za-z0-9_]+)/([A-Za-z0-9_]+)/([A-Za-z0-9_]+)", SelectionHandler),
        (r"/flags/([A-Za-z0-9_]+)", ImageHandler, {
            'location': os.path.join(os.path.dirname(__file__), 'flags', '%s'),
            'fallback': os.path.join(os.path.dirname(__file__), 'static', 'flag.png')
        }),
        ], **{
        "login_url": "/",
        "template_path": os.path.join(os.path.dirname(__file__), "templates"),
        "static_path": os.path.join(os.path.dirname(__file__), "static"),
        "cookie_secret": base64.b64encode("000000000000000000000"),
        })
    application.listen(8891)

    try:
        IOLoop.instance().start()
    except KeyboardInterrupt:
        # Exit cleanly.
        return

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def start_tornado():
	myCookie = Hash.MD5(Dict['SharedSecret'] + NAME)

	settings = {"cookie_secret": "__" + myCookie + "__",
							"login_url": "/login"}

	application = Application(httpHandlers, **settings)
	applicationTLS = Application(httpsHandlers, **settings)
	http_server = HTTPServer(application)
	# Use our own certificate for TLS
	http_serverTLS = HTTPServer(applicationTLS, 
													ssl_options={
																			"certfile": os.path.join(Core.bundle_path, 'Contents', 'Code', 'Certificate', 'WebTools.crt'),
																			"keyfile": os.path.join(Core.bundle_path, 'Contents', 'Code', 'Certificate', 'WebTools.key')})


	# Set web server port to the setting in the channel prefs
	port = int(Prefs['WEB_Port_http'])
	ports = int(Prefs['WEB_Port_https'])	
	http_server.listen(port)
	http_serverTLS.listen(ports)

	Log.Debug('Starting tornado on ports %s and %s' %(port, ports))
	IOLoop.instance().start()
	Log.Debug('Shutting down tornado')

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def tornado_start():  # pragma: no cover
    """Just start tornado ioloop

    :return: None
    """
    from tornado.ioloop import IOLoop
    IOLoop.instance().start()

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
 def run(self, *args, **kwargs):
     super(Service, self).run(*args, **kwargs)
     self.periodicalCb = PeriodicCallback(
         partial(super(Service, self).run, *args, **kwargs),
         self.interval, IOLoop.instance())
     self.periodicalCb.start()
     IOLoop.instance().start()

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
  def _update_assignment_watch(self, children):
    """ Watches for new or lost groomers.

    Args:
      children: A list of strings specifying registered groomers.
    """
    IOLoop.instance().add_callback(self._update_assignment, children)

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
def start_tornado():
    myCookie = Hash.MD5(Dict['SharedSecret'] + NAME)
    login_url = BASEURL + '/login'
    settings = {"cookie_secret": "__" + myCookie + "__",
                "login_url": login_url}
    try:
        application = Application(httpHandlers, **settings)
        applicationTLS = Application(httpsHandlers, **settings)
        http_server = HTTPServer(application)
        # Use our own certificate for TLS
        CRTFile = os.path.join(Core.bundle_path, 'Contents',
                               'Code', 'Certificate', Prefs['Cert_CRT'])
        Log.Info('Certificate crt file is %s' % CRTFile)
        KEYFile = os.path.join(Core.bundle_path, 'Contents',
                               'Code', 'Certificate', Prefs['Cert_KEY'])
        Log.Info('Certificate key file is %s' % KEYFile)
        http_serverTLS = HTTPServer(applicationTLS,
                                    ssl_options={
                                        "certfile": os.path.join(Core.bundle_path, 'Contents', 'Code', 'Certificate', CRTFile),
                                        "keyfile": KEYFile})
        # Set web server port to the setting in the channel prefs
        port = int(Prefs['WEB_Port_http'])
        ports = int(Prefs['WEB_Port_https'])
        http_server.listen(port)
        http_serverTLS.listen(ports)
        Log.Debug('Starting tornado on ports %s and %s' % (port, ports))
        IOLoop.instance().start()
    except Exception, e:
        Log.Exception('Problem starting Tornado: ' + str(e))

# 需要导入模块: from tornado.ioloop import IOLoop [as 别名]
# 或者: from tornado.ioloop.IOLoop import instance [as 别名]
 def _on_finish():
     try:
         zs_response = self.zsle_request(data['sim'])
         zlp = ZsLeParser(zs_response.replace('GBK', 'UTF-8'))
         if zlp.success == "0":
              ret.success = ErrorCode.SUCCESS
              ret.position = zlp.get_position()
              ret.info = ErrorCode.ERROR_MESSAGE[ret.success]
              logging.info("[LE] Zsle response position: %s, sim:%s", ret.position, data['sim'])
         else:
             if zlp.success == "9999228":
                 callback = partial(self.re_subscription, data['sim'])
                 IOLoop.instance().add_timeout(int(time.time()) + 5, callback)
             logging.info("[LE] Zsle request failed, errorcode: %s, info: %s, sim:%s",
                          zlp.success, zlp.info, data['sim'])
             # logging.info('[LE] Google request:\n %s', request)
             # response = self.send(ConfHelper.LBMP_CONF.le_host, 
             #                      ConfHelper.LBMP_CONF.le_url, 
             #                      request,
             #                      HTTP.METHOD.POST)
             # logging.info('[LE] Google response:\n %s', response.decode('utf8'))
             # json_data = json_decode(response)
             # if json_data.get("location"):
             #     ret.position.lat = int(json_data["location"]["latitude"] * 3600000)
             #     ret.position.lon = int(json_data["location"]["longitude"] * 3600000)
             #     ret.success = ErrorCode.SUCCESS 
             #     ret.info = ErrorCode.ERROR_MESSAGE[ret.success]
     except Exception as e:
         logging.exception("[LE] Get latlon failed. Exception: %s, sim:%s", e.args, data['sim'])
     self.write(ret)
     IOLoop.instance().add_callback(self.finish)