龙卷风 - 如何在另一个函数中调用处理程序

Question

我目前正在尝试每次调用某个函数时都使用Tornado的web套接字处理程序来更新仪表板。这里是处理：

class WebSocketHandler(websocket.WebSocketHandler): 
    clients = [] 
    def open(self): 
     logging.info("WEBSOCKET OPEN") 
     WebSocketHandler.clients.append(self) 
    def on_message(self, message): 
     logging.info("message from websocket recieved") 
     self.write_message("WebSocket connected") 
    def on_close(self): 
     logging.info("WEBSOCKET closed") 

，这里是客户端脚本，负载连接的WebSocket：

function WebSocketTest() 
{ var ws = 0; 
    ws = new WebSocket("ws://localhost:8008/WEB"); 
    ws.onopen = function() 
    { 
    ws.send("initial connect") 
    } 

    ws.onmessage = function (evt) 
    { 
    console.log(evt.data) 
    }; 

    ws.onclose = function() 
    { 
    console.log("closed "); 
    }; 
} 

的的WebSockets成功地连接。

我需要呼叫write_message从WebSocketHandler但我很困惑它的实例是什么？我不断遇到的错误是self isn't defined，但我不知道什么是自己是什么？我知道WebSocketHandler获取运行每当客户端尝试加载^/WEB$

编辑：这里是我的server.py文件，我需要调用write_message在itercheckers

class Server(): 



@classmethod 
def run(cls): 
    options.parse_command_line() 
    # Start web 
    template_path = os.path.join(os.path.dirname(__file__), 'templates') 
    jinja2loader = Jinja2Loader(template_path) 
    kwargs = dict(
     template_loader=jinja2loader, 
     static_path=os.path.join(os.path.dirname(__file__), 'static'), 
     debug=True, 
     login_url="/auth/login", 
     cookie_secret="dn470h8yedWF9j61BJH2aY701i6UUexx" 
    ) 
    app = web.Application(handlers, **kwargs).listen(
     configuration['server']['port'],) 

    # Reset events 
    @gen.coroutine 
    def reset(parent=None): 
     if parent is None: 
      parent = configuration 
     # Reset event happyness 
     yield events.reset_happy(parent) 
     # Read last status 
     data = yield events.get(parent) 
     # Read and set happy from the last status 
     happy = (data or {}).get('status', events.STATUS_OK) \ 
      in events.HAPPY 
     yield events.set_happy(parent, happy) 
     # Iterate sub-events 
     for event in parent['events']: 
      yield reset(event) 

    ioloop.IOLoop.current().run_sync(reset) 



    # Start checkers 
    def itercheckers(parent): 
     index = 0 
     for event in parent.get('events', []): 
      if 'checker' in event: 
       checker = event['checker'] 
       p, m = checker['class'].rsplit('.', 1) 
       ioloop.IOLoop.current().spawn_callback(
        getattr(importlib.import_module(p), m)(
         event=event, 
         frequency=checker.get('frequency', 1), 
         params=checker['params'] 
        ).run) 
      index += 1 
      itercheckers(event) 
    itercheckers(configuration) 



    # Start alerts 
    ioloop.IOLoop.current().run_sync(alerts.reset) 
    for alert in configuration['alerts']: 
     p, m = alert['class'].rsplit('.', 1) 
     ioloop.IOLoop.current().spawn_callback(
      getattr(importlib.import_module(p), m)(
       alert=alert 
      ).run 
     ) 

    # Start loop 
    ioloop.IOLoop.current().start() 

Answer 1

的 spawn callback电话

第一件事，第一，self关键字之后指向当前处理的当前websocket客户端。要使用龙卷风的WebSockets，你必须初始化龙卷风应用

app = web.Application([ 
    (r'/ws', WSHandler), #tells it to redirect ws:// to websocket handler 
#Choose different names from defaults because of clarity 
]) 

if __name__ == '__main__': 
    app.listen(5000) #listen on what port 
    ioloop.IOLoop.instance().start() 

然后，你必须有WSHandler类你指向的WebSockets TRAFIC到

class WSHandler(websocket.WebSocketHandler): 
    #crossdomain connections allowed 
    def check_origin(self, origin): 
     return True 
    #when websocket connection is opened 
    def open(self): 
     print("Client connected ") 

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

    def on_message(self,message): 
     self.write_message(message) #echo back whatever client sent you 

所以完整的应用程序看起来像

from tornado import websocket, web, ioloop 
clients = [] 

#whenever you want to broadcast to all connected call this function 
def broadcast_message(msg): 
    global clients 
    for client in clients: 
     client.write_message(msg) 

class WSHandler(websocket.WebSocketHandler): 
    #crossdomain connections allowed 
    def check_origin(self, origin): 
     return True 
    #when websocket connection is opened 
    def open(self): 
     #here you can add clients to your client list if you want 
     clients.append(self) 
     print("Client connected ") 

    def on_close(self): 
     clients.remove(self) 
     print("Client disconnected") 

    def on_message(self,message): 
     self.write_message(message) #echo back whatever client sent you 

app = web.Application([ 
    (r'/ws', WSHandler), #tells it to redirect ws:// to websocket handler 
#Choose different names from defaults because of clarity 
]) 

if __name__ == '__main__': 
    app.listen(5000) #listen on what port 
    ioloop.IOLoop.instance().start() 

而且现在连接到它与js

function WebSocketTest() 
{ 
    var ws = new WebSocket("ws://localhost:5000/ws"); 
    ws.onopen = function() 
    { 
     ws.send("initial connect") 
    } 

    ws.onmessage = function (evt) 
    { 
     console.log(evt.data) 
    }; 

    ws.onclose = function() 
    { 
     console.log("closed "); 
    }; 
} 

我还没有测试过，但应该可以工作