Senden von Nachrichten aktiv von Tornado WebSocket-Server

Question

Ich habe einen Python WebSocket-Server. Dies kann eine Antwort zurückgeben, wenn es eine Nachricht empfängt.

import tornado.web 
import tornado.websocket 
import tornado.ioloop 

class WebSocketHandler(tornado.websocket.WebSocketHandler): 

    def open(self): 
     print("New client connected") 
     self.write_message("You are connected") 

    def on_message(self, message): 
     self.write_message(u"You said: " + message) 

    def on_close(self): 
     print("Client disconnected") 

    def check_origin(self, origin): 
     return True 

application = tornado.web.Application([ 
     (r"/", WebSocketHandler), 
]) 


if __name__ == "__main__": 
    application.listen(8888) 
    tornado.ioloop.IOLoop.instance().start() 

Dies kann jedoch keine Nachrichten senden, bevor es einen empfängt. Wie sende ich eine Nachricht aktiv? Zum Beispiel misst es die Zeit und wenn es 10 Sekunden lang keine Nachrichten empfangen hat, sendet es "Schläfst du?".

Ich möchte Chatbot mit WebSocket machen. Ich benutze Tornado und Websocket, weil ich das nur weiß, und ich wäre interessiert, wenn Sie von besseren Methoden in dieser Hinsicht wissen.

Answer 1

Sie einen Zeitplan mit tornado.ioloop.PeriodicCallback hinzufügen und einfach zu überprüfen, ob es Aktivität oder nicht, basierend auf Zeit gewesen ist, wie die folgenden (ich aus dem Code angepasst und this answer):

import tornado.web 
import tornado.websocket 
import tornado.ioloop 
import time 

class WebSocketHandler(tornado.websocket.WebSocketHandler): 
    def simple_init(self): 
     self.last = time.time() 
     self.stop = False 

    def open(self): 
     self.simple_init() 
     print("New client connected") 
     self.write_message("You are connected") 
     self.loop = tornado.ioloop.PeriodicCallback(self.check_ten_seconds, 1000, io_loop=tornado.ioloop.IOLoop.instance()) 
     self.loop.start() 

    def on_message(self, message): 
     self.write_message(u"You said: " + message) 
     self.last = time.time() 

    def on_close(self): 
     print("Client disconnected") 
     self.loop.stop() 

    def check_origin(self, origin): 
     return True 

    def check_ten_seconds(self): 
     print("Just checking") 
     if (time.time() - self.last > 10): 
      self.write_message("You sleeping mate?") 
      self.last = time.time() 

Jetzt mit einem Client-Wechsel zwischen Leerlauf und Schreiben (von here angepasst):

class Client(object): 
    def __init__(self, url, timeout): 
     self.url = url 
     self.timeout = timeout 
     self.ioloop = IOLoop.instance() 
     self.ws = None 
     self.connect() 
     PeriodicCallback(self.keep_alive, 20000, io_loop=self.ioloop).start() 
     self.ioloop.start() 

    @gen.coroutine 
    def connect(self): 
     print("trying to connect") 
     try: 
      self.ws = yield websocket_connect(self.url) 
     except Exception as e: 
      print("connection error") 
     else: 
      print("connected") 
      self.run() 

    @gen.coroutine 
    def run(self): 
     once = False 
     while True: 
      msg = yield self.ws.read_message() 
      print(msg) 
      if once: 
       time.sleep(11) 
       once = False 
      else: 
       time.sleep(1) 
       once = True 
      self.ws.write_message("Hello matey") 
      if msg is None: 
       print("connection closed") 
       self.ws = None 
       break 

    def keep_alive(self): 
     if self.ws is None: 
      self.connect() 
     else: 
      self.ws.write_message("keep alive") 

wir die erwartete Ausgabe erhalten:

trying to connect 
connected 
You are connected 
You said: Hello matey 
You sleeping mate? 
You said: Hello matey 
You said: Hello matey 
You sleeping mate?