def _on_server_start(server):
_print_url()
def maybe_open_browser():
if config.get_option("server.headless"):
# Don't open browser when in headless mode.
return
if server.browser_is_connected:
# Don't auto-open browser if there's already a browser connected.
# This can happen if there's an old tab repeatedly trying to
# connect, and it happens to success before we launch the browser.
return
if config.is_manually_set("browser.serverAddress"):
addr = config.get_option("browser.serverAddress")
else:
addr = "localhost"
util.open_browser(Report.get_url(addr))
# Schedule the browser to open using the IO Loop on the main thread, but
# only if no other browser connects within 1s.
ioloop = tornado.ioloop.IOLoop.current()
ioloop.call_later(BROWSER_WAIT_TIMEOUT_SEC, maybe_open_browser)
def open(self):
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.call_later(self._KEEPALIVE_PING_TIMEOUT, self._send_ping)
ioloop.add_callback(lambda: log.info('Client connected: {0}'.format(self)))
self._get_id()
self._CLIENTS[self.id] = self
self._log_client_list()
def main():
sc = tornado.stack_context.StackContext(contextor)
with sc:
async_task()
sc2 = tornado.stack_context.StackContext(contextor2)
with sc2:
ioloop.call_later(5, ioloop.stop)
ioloop.start()
print("ioloop start ...")
print('end')
def main():
tornado.options.parse_command_line()
application = tornado.web.Application(mappings)
application.listen(options.port)
tornado.ioloop.PeriodicCallback(ResultCache.update, 1800000).start()
ioloop = tornado.ioloop.IOLoop.current()
ioloop.call_later(1000, ResultCache.update())
ioloop.start()
def run(args):
cache = Cache('gsiftp://gridftp-scratch.icecube.wisc.edu/local/simprod/')
#cache = Cache('gsiftp://gridftp-3.icecube.wisc.edu/mnt/lfs4/simprod/dagtemp2/test/')
ioloop = tornado.ioloop.IOLoop.current()
for i in range(args.num):
ioloop.call_later(i*60,run_dag,Corsika(cache))
for t in range(1,101):
ioloop.call_later(i*t*6,run_dag,NuGen_Systematics(cache))
logging.warn('starting')
ioloop.start()
logging.warn('done')
def on_open(self, info: ConnectionInfo) -> None:
log_data = dict(extra='[transport=%s]' % (self.session.transport_name,))
record_request_start_data(log_data)
ioloop = tornado.ioloop.IOLoop.instance()
self.authenticated = False
self.session.user_profile = None
self.close_info = None # type: Optional[CloseErrorInfo]
self.did_close = False
try:
self.browser_session_id = info.get_cookie(settings.SESSION_COOKIE_NAME).value
self.csrf_token = info.get_cookie(settings.CSRF_COOKIE_NAME).value
except AttributeError:
# The request didn't contain the necessary cookie values. We can't
# close immediately because sockjs-tornado doesn't expect a close
# inside on_open(), so do it on the next tick.
self.close_info = CloseErrorInfo(403, "Initial cookie lacked required values")
ioloop.add_callback(self.close)
return
def auth_timeout() -> None:
self.close_info = CloseErrorInfo(408, "Timeout while waiting for authentication")
self.close()
self.timeout_handle = ioloop.call_later(10, auth_timeout)
write_log_line(log_data, path='/socket/open', method='SOCKET',
remote_ip=info.ip, email='unknown', client_name='?')
def on_open(self, info: ConnectionInfo) -> None:
log_data = dict(extra='[transport=%s]' % (self.session.transport_name,))
record_request_start_data(log_data)
ioloop = tornado.ioloop.IOLoop.instance()
self.authenticated = False
self.session.user_profile = None
self.close_info = None # type: Optional[CloseErrorInfo]
self.did_close = False
try:
self.browser_session_id = info.get_cookie(settings.SESSION_COOKIE_NAME).value
self.csrf_token = info.get_cookie(settings.CSRF_COOKIE_NAME).value
except AttributeError:
# The request didn't contain the necessary cookie values. We can't
# close immediately because sockjs-tornado doesn't expect a close
# inside on_open(), so do it on the next tick.
self.close_info = CloseErrorInfo(403, "Initial cookie lacked required values")
ioloop.add_callback(self.close)
return
def auth_timeout() -> None:
self.close_info = CloseErrorInfo(408, "Timeout while waiting for authentication")
self.close()
self.timeout_handle = ioloop.call_later(10, auth_timeout)
write_log_line(log_data, path='/socket/open', method='SOCKET',
remote_ip=info.ip, email='unknown', client_name='?')
def _on_server_start(server: Server) -> None:
_maybe_print_old_git_warning(server.script_path)
_print_url(server.is_running_hello)
report_watchdog_availability()
_print_new_version_message()
# Load secrets.toml if it exists. If the file doesn't exist, this
# function will return without raising an exception. We catch any parse
# errors and display them here.
try:
secrets.load_if_toml_exists()
except BaseException as e:
LOGGER.error(f"Failed to load {SECRETS_FILE_LOC}", exc_info=e)
def maybe_open_browser():
if config.get_option("server.headless"):
# Don't open browser when in headless mode.
return
if server.browser_is_connected:
# Don't auto-open browser if there's already a browser connected.
# This can happen if there's an old tab repeatedly trying to
# connect, and it happens to success before we launch the browser.
return
if config.is_manually_set("browser.serverAddress"):
addr = config.get_option("browser.serverAddress")
elif config.is_manually_set("server.address"):
if server_address_is_unix_socket():
# Don't open browser when server address is an unix socket
return
addr = config.get_option("server.address")
else:
addr = "localhost"
util.open_browser(Report.get_url(addr))
# Schedule the browser to open using the IO Loop on the main thread, but
# only if no other browser connects within 1s.
ioloop = tornado.ioloop.IOLoop.current()
ioloop.call_later(BROWSER_WAIT_TIMEOUT_SEC, maybe_open_browser)
def text(self, text, timeout=None):
"""Draws a text with an optional timeout in miliseconds.
After that, the last frame is restored.
"""
image = Image.new(self.device.mode, self.device.size)
draw = ImageDraw.Draw(image)
draw.text((5, 35), text, fill='white', align='center', font=self.font)
self.draw(image, frame=False)
if timeout:
ioloop = tornado.ioloop.IOLoop.current()
if self.runner:
ioloop.remove_timeout(self.runner)
func = functools.partial(self.draw, self.frame, frame=False)
self.runner = ioloop.call_later(timeout / 1000.0, func)
def connect_handler(self, handler_id: int, client_name: str) -> None:
self.current_handler_id = handler_id
self.current_client_name = client_name
set_descriptor_by_handler_id(handler_id, self)
self.last_connection_time = time.time()
def timeout_callback() -> None:
self._timeout_handle = None
# All clients get heartbeat events
self.add_event(dict(type='heartbeat'))
ioloop = tornado.ioloop.IOLoop.instance()
interval = HEARTBEAT_MIN_FREQ_SECS + random.randint(0, 10)
if self.client_type_name != 'API: heartbeat test':
self._timeout_handle = ioloop.call_later(interval, timeout_callback)
def connect_handler(self, handler_id: int, client_name: Text) -> None:
self.current_handler_id = handler_id
self.current_client_name = client_name
set_descriptor_by_handler_id(handler_id, self)
self.last_connection_time = time.time()
def timeout_callback() -> None:
self._timeout_handle = None
# All clients get heartbeat events
self.add_event(dict(type='heartbeat'))
ioloop = tornado.ioloop.IOLoop.instance()
interval = HEARTBEAT_MIN_FREQ_SECS + random.randint(0, 10)
if self.client_type_name != 'API: heartbeat test':
self._timeout_handle = ioloop.call_later(interval, timeout_callback)
async def getChatInfo(roomid):
url = CHATINFOURL + roomid
http_client = AsyncHTTPClient()
res = await http_client.fetch(url)
chatInfo = json.loads(res.body)
chatAddr = chatInfo['data']['chat_addr_list'][0]
socketIP, socketPort = chatAddr.split(':')
print('chat ip:', socketIP)
print('chat port:', socketPort)
stream = await TCPClient().connect(socketIP, socketPort)
rid = str(chatInfo['data']['rid']).encode('utf-8')
appid = str(chatInfo['data']['appid']).encode('utf-8')
authtype = str(chatInfo['data']['authType']).encode('utf-8')
sign = str(chatInfo['data']['sign']).encode('utf-8')
ts = str(chatInfo['data']['ts']).encode('utf-8')
msg = b'u:' + rid + b'@' + appid + b'\nk:1\nt:300\nts:' + ts + b'\nsign:' + sign + b'\nauthtype:' + authtype
msgLen = len(msg)
sendMsg = FIRST_REQ + int.to_bytes(msgLen, 2, 'big') + msg
await stream.write(sendMsg)
recvMsg = await stream.read_bytes(CHECK_LEN)
if recvMsg == FIRST_RPS:
print('成功连接弹幕服务器')
recvLen = int.from_bytes(await stream.read_bytes(2), 'big')
await stream.read_bytes(recvLen)
ioloop.call_later(0, KeepAlive, stream)
while True:
recvMsg = await stream.read_bytes(CHECK_LEN)
if recvMsg == RECVMSG:
recvLen = int.from_bytes(await stream.read_bytes(2), 'big')
recvMsg = stream.read_bytes(recvLen) #ack:0
totalLen = int.from_bytes(await stream.read_bytes(META_LEN), 'big')
try:
await analyseMsg(stream, totalLen)
except Exception as e:
pass
def push():
for app, app_config in info.gramexlog.apps.items():
for item in app_config.queue:
item['_index'] = app_config.get('index', app)
try:
helpers.bulk(app_config.conn, app_config.queue)
app_config.queue.clear()
except Exception:
# TODO: If the connection broke, re-create it
# This generic exception should be caught for thread to continue its execution
app_log.exception('gramexlog: push to %s failed', app)
if 'handle' in info.gramexlog:
ioloop.remove_timeout(info.gramexlog.handle)
# Call again after flush seconds
info.gramexlog.handle = ioloop.call_later(flush, push)
def _send_ping(self):
if self.ws_connection:
ioloop = tornado.ioloop.IOLoop.instance()
if isinstance(self.ws_connection, tornado.websocket.WebSocketProtocol13):
future = tornado.gen.Future()
seq = struct.pack(">q", int(time.time() * 1000))
self._ping[seq] = future
self.ping(seq)
else:
future = self.call('ping', seq=time.time())
ioloop.call_later(
self._KEEPALIVE_PING_TIMEOUT,
lambda: self.close() if future.running() else None
)
resp = yield future
ts = resp.get('seq', 0)
delta = (time.time() - (ts/1000.))
log.debug("%r Pong recieved: %.4f" % (self, delta))
if delta > self._CLIENT_TIMEOUT:
self.close()
ioloop.call_later(self._KEEPALIVE_PING_TIMEOUT, self._send_ping)
def gramexlog(conf):
'''Set up gramexlog service'''
from gramex.transforms import build_log_info
try:
from elasticsearch import Elasticsearch, helpers
except ImportError:
app_log.error(
'gramexlog: elasticsearch missing. pip install elasticsearch')
return
# We call push() every 'flush' seconds on the main IOLoop. Defaults to every 5 seconds
flush = conf.pop('flush', 5)
ioloop = info._main_ioloop or tornado.ioloop.IOLoop.current()
# Set the defaultapp to the first config key under gramexlog:
if len(conf):
info.gramexlog.defaultapp = next(iter(conf.keys()))
for app, app_conf in conf.items():
app_config = info.gramexlog.apps[app] = AttrDict()
app_config.queue = []
keys = app_conf.pop('keys', [])
# If user specifies keys: [port, args.x, ...], these are captured as additional keys.
# The keys use same spec as Gramex logging.
app_config.extra_keys = build_log_info(keys)
# Ensure all gramexlog keys are popped from app_conf, leaving only Elasticsearch keys
app_config.conn = Elasticsearch(**app_conf)
def push():
for app, app_config in info.gramexlog.apps.items():
for item in app_config.queue:
item['_index'] = app_config.get('index', app)
try:
helpers.bulk(app_config.conn, app_config.queue)
app_config.queue.clear()
except Exception:
# TODO: If the connection broke, re-create it
# This generic exception should be caught for thread to continue its execution
app_log.exception('gramexlog: push to %s failed', app)
if 'handle' in info.gramexlog:
ioloop.remove_timeout(info.gramexlog.handle)
# Call again after flush seconds
info.gramexlog.handle = ioloop.call_later(flush, push)
info.gramexlog.handle = ioloop.call_later(flush, push)
info.gramexlog.push = push
def start_hb(self):
logger.debug("start_hb for %s", self.id)
hb = self.channels["hb"]
ioloop = tornado.ioloop.IOLoop.current()
def pong(message):
#logger.debug("pong for %s", self.id)
self._expecting_pong = False
hb.on_recv(pong)
self._expecting_pong = False
def ping():
#logger.debug("ping for %s", self.id)
now = ioloop.time()
if self._expecting_pong:
logger.warning("kernel %s died unexpectedly", self.id)
self.stop()
elif now > self.hard_deadline:
logger.info("hard deadline reached for %s", self.id)
self.stop()
elif (self.timeout > 0
and now > self.deadline
and self.status == "idle"):
logger.info("kernel %s timed out", self.id)
self.stop()
else:
hb.send(b'ping')
self._expecting_pong = True
self._hb_periodic_callback = tornado.ioloop.PeriodicCallback(
ping, config.get("beat_interval") * 1000)
def start_ping():
logger.debug("start_ping for %s", self.id)
if self.alive:
self._hb_periodic_callback.start()
self._start_ping_handle = ioloop.call_later(
config.get("first_beat"), start_ping)
self.alive = True
def game_invite(self, invitees):
players = {}
for invitee in invitees:
player = self.users[invitee]
#Abort the invite if an invitee is already in a game or has accepted an invite
if player.current_game:
return False
else:
players[invitee] = player
game = coup.CoupGame(self, players)
game.id = str(id(game))
self.games[game.id] = game
#Add the invite for all players
for player in game.user_sockets:
player.invites[game.id] = game
game.invite()
#Cancel the game/invitation after a timeout if not everybody accepted
game.invite_tout_handle = ioloop.call_later(10, self.game_cancel, game)
return True
# print("checking for file change")
# print(restart_server)
if (restart_server):
print("updating the bigquery client")
server.stop()
server = None
server = start_app()
ioloop.add_callback(ioloop.stop)
class WatchDogEvent(LoggingEventHandler):
def on_modified(self, event):
global restart_server
restart_server = True
if __name__ == "__main__":
path = sys.argv[1] if len(sys.argv) > 1 else '.'
observer = Observer()
observer.schedule(WatchDogEvent(), path, recursive=True)
server = start_app()
observer.start()
try:
while True:
ioloop.call_later(callback=restart_tornado, delay=1)
ioloop.start()
time.sleep(2)
except KeyboardInterrupt:
observer.stop()
observer.join()
def refresh():
app.soc_runner.loop()
ioloop.call_later(15, refresh)
def refresh():
app.soc_runner.loop()
ioloop.call_later(15, refresh)
await analyseMsg(stream, totalLen)
except Exception as e:
pass
async def analyseMsg(s, totalLen):
while totalLen > 0:
await s.read_bytes(IGNORE_LEN)
recvLen = int.from_bytes(await s.read_bytes(META_LEN), 'big')
recvMsg = await s.read_bytes(recvLen)
# recv the whole msg.
while recvLen > len(recvMsg):
recvMsg = b''.join(recvMsg, s.recv(recvLen - len(recvMsg)))
await formatMsg(recvMsg)
totalLen = totalLen - IGNORE_LEN - META_LEN - recvLen
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-l", "--roomid", dest="roomid", help="roomid")
(options, args) = parser.parse_args()
print('options:', options)
ioloop = tornado.ioloop.IOLoop.current()
#ioloop.call_later(0,contral_camera,'787552313',2,0,2)
#print('run request')
ioloop.call_later(3, getChatInfo, options.roomid)
ioloop.start()
#
