Tornado:在端口 80 上运行 websocket 和闪存策略服务器

Question

我想使用 Tornado 在端口 80 上运行 websocket 和闪存策略文件服务器。不想在默认端口 843 上运行服务器的原因是它在公司网络中经常关闭。是否可以这样做，如果是，我应该怎么做？

我尝试了以下结构，似乎不起作用：websocket 连接有效，但策略文件请求未路由到TCPHandler。

#!/usr/bin/python
import tornado.httpserver
import tornado.ioloop
import tornado.web
import tornado.websocket
import tornado.gen
from tornado.options import define, options
from tornado.tcpserver import TCPServer

define("port", default=80, help="run on the given port", type=int) 
class FlashPolicyServer(TCPServer):
    def handle_stream(self, stream, address):
        self._stream = stream
        self._read_line()
    def _read_line(self):
        self._stream.read_until('n', self._handle_read)
    def _handle_read(self, data):
        policyFile = ""
        self._stream.write(policyFile)
        self._read_line()

class WebSocketHandler(tornado.websocket.WebSocketHandler):
    def open(self):
        pass
    def on_message(self, message):
        pass
    def on_close(self):
        pass

def main():
    tornado.options.parse_command_line()
    mainLoop = tornado.ioloop.IOLoop.instance()
    app = tornado.web.Application(
        handlers=[
            (r"/websocket", WebSocketHandler),
            (r"/", FlashPolicyServer)
        ], main_loop=mainLoop
    )
    httpServer = tornado.httpserver.HTTPServer(app)
    httpServer.listen(options.port)
    mainLoop.start()
if __name__ == "__main__":
    main()

有什么想法吗？如果这是不可能的，另一个想法是通过端口 443 提供策略文件吗？

Answer 1

您的方法存在两个问题：

1. TCPServer 是这样用的：

   server = TCPServer（）服务器听（6666）IOLoop.instance（）.start（）

   在删除(r"/", FlashPolicyServer)行后，这将解决问题。

   但您希望使用端口 80。

2. 但是，您不能这样做，因为您需要在该端口上拥有另一个 HTTP 服务器。

因此，您可以做的是使用nginx并将端口 80 设置为/websocket的反向代理，否则提供 Flash 策略文件。

Answer 2

我通过猴子修补IOStream和HTTPServer解决了这个问题：

def prepend_to_buffer(self, chunk):
    self._read_buffer.appendleft(chunk)
    self._read_buffer_size += len(chunk)
    if self._read_buffer_size >= self.max_buffer_size:
        logging.error("Reached maximum read buffer size")
        self.close()
        raise IOError("Reached maximum read buffer size")
    return len(chunk)
def first_data_handler(self, data):
    if data == '<policy-file-request/>':
        self.stream.write(policy_file + '')
    else:
        self.stream.prepend_to_buffer(data)
        tornado.httpserver.HTTPConnection(self.stream, self.address, self.request_callback,self.no_keep_alive, self.xheaders)
def handle_stream(self, stream, address):
    self.stream = stream
    self.address = address
    self.stream.read_bytes(23, self.first_data_handler)
tornado.iostream.IOStream.prepend_to_buffer = prepend_to_buffer
tornado.httpserver.HTTPServer.first_data_handler = first_data_handler
tornado.httpserver.HTTPServer.handle_stream = handle_stream