0

我想在将图像（.pgm）写入虚拟磁盘后立即通过 TCP 发送它。为此，我正在使用 pyinotify 和套接字。图片发送后，我想告诉服务器现在停止。一切正常，但最后一部分给了我以下错误：

if data.decode('utf-8') == 'stop': UnicodeDecodeError: 'utf-8' codec can't
decode byte 0x88 in position 319: invalid start byte

客户：

import pyinotify
import socket
import traceback
import sys


class ModHandler(pyinotify.ProcessEvent):
    def __init__(self, socket, buffer_size):
        self.socket = socket
        self.buffer_size = buffer_size

    def process_IN_CLOSE_WRITE(self, event):
        try:
            self.socket.send(bytes(event.pathname, encoding='utf-8'))
            file = open(event.pathname, "rb")
            line = file.read(self.buffer_size) 
            while(line):
                self.socket.send(line)  
                line = file.read(self.buffer_size)

        except Exception:
            traceback.print_exc()
        finally:
            try:
                self.socket.send(bytes('stop', encoding='utf-8'))
                print("done")
                file.close
            except Exception:
                traceback.print_exc()

class TCPStream():
    def __init__(self, ip, port, buffer_size):
        self.ip = ip
        self.port = port
        self.buffer_size = buffer_size
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            self.socket.connect((self.ip, self.port))
        except Exception:
            traceback.print_exc()

    def __del__(self):
        try:
            self.socket.close()
        except Exception:
            traceback.print_exc()


stream = TCPStream('127.0.0.1', 5005, 1024)

handler = ModHandler(stream.socket, stream.buffer_size)
wm = pyinotify.WatchManager()
notifier = pyinotify.Notifier(wm, handler)
wd_value = wm.add_watch("/media/ram_disk", pyinotify.IN_CLOSE_WRITE)
if wd_value["/media/ram_disk"] <= 0:
    print("can't add watchmanager to the ram_disk... insufficient
    authorization? another watchmanager already running?")
    sys.exit(0)
notifier.loop()

服务器：

import socket


TCP_IP = '127.0.0.1'
TCP_PORT = 5005
BUFFER_SIZE = 1024 

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TCP_IP, TCP_PORT))
s.listen(1)
conn, addr = s.accept()
print("connection address: ", addr)

path = conn.recv(BUFFER_SIZE).decode('utf-8')
filename = path.split("/")

with open(filename[3], 'wb') as f:
    data = conn.recv(BUFFER_SIZE)
    while data:
        print("receiving...")
        f.write(data)
        data = conn.recv(BUFFER_SIZE)

        if not data: 
            break

        if data.decode('utf-8') == 'stop':
            f.close()
            print("done")
            break

conn.close()

目标是有一个恒定的 TCP 图像流写入 ramdisk。因此，我想通过 Bytes 与服务器通信，告诉他该做什么。似乎在传输第一张图片后，它会以某种方式中断。任何帮助表示赞赏！

4

1 回答 1

0

如果图像中缓冲区开头的四个连续字节恰好与 ASCII（和 UTF-8）字符匹配s t o p怎么办？另外，接收方如何知道文件名何时结束，文件数据何时开始？

您应该创建一个二进制编码来构建数据的各个位。这使得整个过程具有很好的确定性。这通常最好使用struct模块pack和unpack方法来完成。给定您要发送的文件，客户端：

import os
import struct

    ...
    pathname = event.pathname.encode('utf-8')  # Encode pathname into bytes
    pathname_len = len(pathname)
    file = open(event.pathname, "rb")
    filesize = os.path.getsize(event.filename) # Get file size
    # Encode size of file name, and size of file into a binary header
    header_format = struct.Struct("!II")
    header = header_format.pack(pathname_len, filesize)
    self.socket.sendall(header)
    self.socket.sendall(pathname)
    while True:
        line = file.read(self.buffer_size)
        if not line: break # EOF
        self.socket.sendall(line)

    # (Remove sending of 'stop' from finally block)

请注意使用sendall确保发送整个缓冲区（send仅发送缓冲区的一部分是合法的，但如果您不考虑它可能会导致丢失字节）。

服务器端将如下所示：

import struct

    ...
    def recv_exactly(s, buffer_len):
        """ This is the converse of sendall """
        data = b''
        rem_bytes = buffer_len
        while rem_bytes > 0:
            buf = s.recv(rem_bytes)
            if not buf:
                raise Exception("Received EOF in middle of block")
            data += buf
            rem_bytes -= len(buf)
        return data

    conn, addr = s.accept()
    ...

    header_format = struct.Struct("!II")
    # Receive exactly the bytes of the header
    header = recv_exactly(conn, header_format.size)
    pathname_len, file_len = header_format.unpack(header)
    path = recv_exactly(conn, pathname_len)
    filename = path.split("/")
    ...
    rem_bytes = file_len
    while rem_bytes > 0:
        data = conn.recv(min(rem_bytes, BUFFER_SIZE))
        if not data:
            raise Exception("Received EOF in middle of file")
        f.write(data)
        rem_bytes -= len(data)

此模型的另一个重要优点是您现在对一个文件和下一个文件之间的边界有了一个清晰的概念（没有可能出现在数据中的“信号值”）。接收者总是知道在当前文件结束之前还剩下多少字节，发送者可以简单地继续发送新的标题、路径名和文件，而无需打开新的连接。

于 2018-10-30T17:13:00.783 回答