TCP python套接字服务器在http客户端上有延迟答案

【问题标题】：TCP python socket server with delay on http clientTCP python套接字服务器在http客户端上有延迟
【发布时间】：2019-03-11 20:42:17
【问题描述】：

我已经开始修改一个用 python 制作的示例，以通过 TCP 服务器流式传输计数器的输出。代码下方

import socket
import sys
import time
from thread import *

HOST = ''   # Symbolic name meaning all available interfaces
PORT = 8888 # Arbitrary non-privileged port

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
print 'Socket created'

#Bind socket to local host and port
try:
    s.bind((HOST, PORT))
except socket.error as msg:
    print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
    sys.exit()

print 'Socket bind complete'

#Start listening on socket
s.listen(10)
print 'Socket now listening'

#Function for handling connections. This will be used to create threads
def clientthread(conn):
    #Sending message to connected client
    #conn.send('Welcome to the server. Type something and hit enter\n') #send only takes string     
    #infinite loop so that function do not terminate and thread do not end.
    count = 0
    while True:
        count = count + 1
        #Receiving from client
        #data = conn.recv(1024)
        #reply = 'OK...' + data
        #if not data: 
        #    break
        reply = str(count)+'\n'
        print reply
        conn.send(reply)
        time.sleep(1)
    #came out of loop
    conn.close()

#now keep talking with the client
while 1:
    #wait to accept a connection - blocking call
    conn, addr = s.accept()
    print 'Connected with ' + addr[0] + ':' + str(addr[1])

    #start new thread takes 1st argument as a function name to be run, second is the tuple of arguments to the function.
    start_new_thread(clientthread ,(conn,))

s.close()

我想使用我的浏览器从远程 http 客户端获取计数器。我必须等待计数器达到至少 260 个计数，然后才能在浏览器上看到它。在第一次 260 计数之后，一切都在服务器和客户端同步运行。我做了不同的尝试来减少发送的缓冲区大小，但每次一开始都会有很大的延迟。

【问题讨论】：

标签： python sockets http tcp delay

【解决方案1】：

浏览器默认会有很大的响应，并且在数据量达到最低限度之前不会呈现：以下链接在Chunked Encoding 中讨论了这个限制，这是一种以块形式发送数据的方法。

using-transfer-encoding-chunked-how-much-data-must-be-sent-before-browsers-s/16909228#16909228

因此，即使您将有效的 HTTP1.0 分块响应系列拼凑在一起，此限制也将适用：浏览器具有有效的标头，并且会以块的形式接受您的数据，但仍会延迟渲染任何内容，直到一堆通过为止。

问题是：您真的需要一个完整的网络浏览器作为客户端吗？有更简单的方法可以从 TCP 流中读取一些原始数据。你可以在 python 中编写一个，或者使用例如netcat 甚至是旧的 telnet 客户端？问题解决了;-)

好吧，说它真的需要一个浏览器.. 比你必须做更多的工作。一种立即发送实时数据的标准 (W3C) 方式是一种称为Server-Sent-Events 的机制。您发送了 Content-Type 文本/事件流，然后是数据，逐行发送，前面是“数据：”：

def clientthread(conn):
    conn.send("HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\n\r\n");
    count = 0
    while True:
        count = count + 1
        conn.send("data: %d\r\n" % (count))
        print count
        time.sleep(1)
    conn.close()

目前有一些库可以习惯性地做到这一点，等等。但我想展示它基本上是多么简单。

.. 但是现在，您需要在客户端 Javascript 中添加一些 EventSource 来理解这一点，例如每次收到新的计数器时，将一些 HTML 元素设置为计数器值。

不止于此。您现在必须提供生成的 HTML 和脚本，如果它不在同一台服务器上，请确保设置各种与安全相关的标头，否则您的浏览器将忽略您的脚本。 .

此外，事情可能很快就会变得复杂，除非这是一项学术练习，否则您将不得不考虑稳健性、标准合规性、边缘情况等。我强烈建议使用更高级别的 HTTP 服务器实现，例如 HTTPServer 和 BaseHTTPRequestHandler为您完成大部分此类工作。

此示例 (python3) 为带有示例 EventSource 的 html (at /) 和带有计数器的 SSE 流 (at /counter) 提供服务：

import sys, time                                                                                                                                                                                                                                
from http.server import HTTPServer,BaseHTTPRequestHandler                                                                                                                                                                                       
from socketserver import ThreadingMixIn                                                                                                                                                                                                         
from socket import error                                                                                                                                                                                                                        

html_and_js = """<html>                                                                                                                                                                                                                         
<head>                                                                                                                                                                                                                                          
    <meta charset="UTF-8">                                                                                                                                                                                                                      
    <title>Counter SSE Client</title>                                                                                                                                                                                                           
</head>                                                                                                                                                                                                                                         
<body>                                                                                                                                                                                                                                          
Count:<span id="counter">0</span>                                                                                                                                                                                                               
<script>                                                                                                                                                                                                                                        
    "use strict";                                                                                                                                                                                                                               
    var counter = document.getElementById('counter');                                                                                                                                                                                           
    var event_source=new EventSource("/counter");                                                                                                                                                                                               
    event_source.onmessage=function(msg) {                                                                                                                                                                                                      
        counter.innerHTML=msg.data;                                                                                                                                                                                                             
    };                                                                                                                                                                                                                                          
    </script>                                                                                                                                                                                                                                   
</body>                                                                                                                                                                                                                                         
</html>                                                                                                                                                                                                                                         
"""                                                                                                                                                                                                                                             

class SSECounterRequestHandler(BaseHTTPRequestHandler):                                                                                                                                                                                         

    server_version = "DzulianisCounter/0.1"                                                                                                                                                                                                     

    def do_html(self):                                                                                                                                                                                                                          
        self.send_header("Content-type", "text/html")                                                                                                                                                                                           
        self.send_header("Access-Control-Allow-Origin", "*")                                                                                                                                                                                    
        self.end_headers()                                                                                                                                                                                                                      
        self.wfile.write(bytes(html_and_js,'UTF-8'))                                                                                                                                                                                            

    def do_sse(self):                                                                                                                                                                                                                           
        self.counter=0                                                                                                                                                                                                                          
        self.send_header("Content-type", "text/event-stream")                                                                                                                                                                                   
        self.send_header("Cache-Control", "no-cache")                                                                                                                                                                                           
        self.end_headers()                                                                                                                                                                                                                      

        self.running=True                                                                                                                                                                                                                       
        while self.running:                                                                                                                                                                                                                     
            try:                                                                                                                                                                                                                                
                self.wfile.write(bytes('data: %d\r\n\r\n' % (self.counter),'UTF-8'))                                                                                                                                                            
                self.counter+=1                                                                                                                                                                                                                 
                time.sleep(1)                                                                                                                                                                                                                   
            except error:                                                                                                                                                                                                                       
                self.running=False                                                                                                                                                                                                              

    def do_GET(self):                                                                                                                                                                                                                           
        self.send_response(200)                                                                                                                                                                                                                 
        if self.path=='/counter':                                                                                                                                                                                                               
            self.do_sse()                                                                                                                                                                                                                       
        else:                                                                                                                                                                                                                                   
            self.do_html()                                                                                                                                                                                                                      

class SSECounterServer(ThreadingMixIn, HTTPServer):                                                                                                                                                                                             
        def __init__(self,listen):                                                                                                                                                                                                              
                HTTPServer.__init__(self,listen,SSECounterRequestHandler)                                                                                                                                                                       

if __name__=='__main__':                                                                                                                                                                                                                        
    if len(sys.argv)==1:                                                                                                                                                                                                                        
            listen_addr=''                                                                                                                                                                                                                      
            listen_port=8888                                                                                                                                                                                                                    
    elif len(sys.argv)==3:                                                                                                                                                                                                                      
            listen_addr=sys.argv[1]                                                                                                                                                                                                             
            listen_port=int(sys.argv[2])                                                                                                                                                                                                        
    else:                                                                                                                                                                                                                                       
            print("Usage: dzulianiscounter.py [<listen_addr> <listen_port>]")                                                                                                                                                                    
            sys.exit(-1)                                                                                                                                                                                                                        

    server=SSECounterServer((listen_addr,listen_port))                                                                                                                                                                                          
    server.serve_forever()

这比例如让页面定期轮询某个 URL，或者颤抖一直在重新加载页面 :-) 以您的速度（每秒 1 次），这也可以保持 http 连接打开，避免连接开销，但会增加一些内存开销到操作系统的网络堆栈，如果你能同时获得许多用户，就会感觉到这一点。

享受吧！

【讨论】：

好的，如果我使用 socat（某种 netcat），它会像您所说的那样工作得很好。我也尝试过使用浏览器再次尝试，但在 python 脚本中使用 Content-Type text/event-stream 方法，但不幸的是，浏览器现在要求我打开或保存文件。为什么？
因为它不能解释你的数据的含义，它会尝试将它保存到一个文件中。 SSE 是一种协议，而不是一种内容类型。浏览器无法知道您向其推送的数据代表什么。这就是为什么它需要客户端代码（在我的完整示例顶部附近的 <script/> 标签之间才能理解它，在这种情况下，它正在更新页面内的计数器，对应于您的 python 代码中的计数器.
好的，现在对我来说更清楚了，但是，我有一个程序（不是我写的，它是编译的）充当 TCP 服务器，它能够流式传输数据，该数据立即由浏览器（根本没有初始延迟）并且根本不需要客户端代码。
你知道它是如何工作的吗？（尝试捕获 HTTP 流量）
好吧，我看了一下这个软件，它每次计数都会产生一个长字符串（140 个字符 = 140 个字节），所以每次我启动浏览器时，我只需要等待 8 个计数（ 1120 字节），这略高于我的浏览器（firefox）的 1024 字节的第一个大响应。所以对我来说，这几乎是瞬时的，但事实并非如此。目前，我正在以对由 1024 个空格组成的客户端的第一个响应来启动服务器端。不那么优雅，但它的工作原理。