Question

我正在将Windows与Python 3.7配合使用，并且尝试在python进程之间异步共享数据（仅字符串）。其中一个无限期运行（接收者），另一个可能在任何时候开始发送一些数据然后结束（发送者）。我正在尝试为此使用命名管道。

当它们同步运行时，我设法做到了（接收者在阻塞的管道上等待直到他获取数据），但是接收者还有其他事情要做，理想情况下，他不应该一直等待。而且在某个时候可能还会有第二个发件人，因此管道阻塞不是很好。

接收方的代码为：

import os
import time
import sys
import win32pipe, win32file, pywintypes

pipe_name = r'\\.\pipe\mypipe' 

pipe = win32pipe.CreateNamedPipe(
        pipe_name,
        win32pipe.PIPE_ACCESS_DUPLEX | win32file.FILE_FLAG_OVERLAPPED,  # open mode 
        win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, # pipe mode
        1, 65536, 65536, # max instances, out buffer size,  in buffer size
        0, # timeout
    None)


while 1:
    print("doing my other stuff")
    try:
        win32pipe.ConnectNamedPipe(pipe, pywintypes.OVERLAPPED())
    except pywintypes.error as e:
        if e.winerror == 232:   #disconnected pipe
            win32pipe.DisconnectNamedPipe(pipe)
            print("Disconnecting pipe")
        else:
            print(e)
    try:
        retval, msg = win32file.ReadFile(pipe, 0, pywintypes.OVERLAPPED())
        print(msg)
    except pywintypes.error as e:
        if e.winerror == 536: #Wating for connection
            print("waiting")
        elif e.winerror == 233: #no process on other side
            continue
    time.sleep(1)

发件人的代码为：

import os
import time
import sys
import win32pipe, win32file, pywintypes


pipe_name = r'\\.\pipe\mypipe' 


for x in range(5):

    handle = win32file.CreateFile(
            pipe_name,
            win32file.GENERIC_READ | win32file.GENERIC_WRITE,
            0,
            None,
            win32file.OPEN_EXISTING,
            win32file.FILE_FLAG_OVERLAPPED,
            None
            )
    res = win32pipe.SetNamedPipeHandleState(handle, win32pipe.PIPE_READMODE_MESSAGE, None, None)
    print(f"sending {x}")
    win32file.WriteFile(handle, str.encode(f"hello world {x}"))
    win32file.CloseHandle(handle)
    time.sleep(2)

现在两者都可以运行并具有一些连接，但是我无法真正获取数据。如果发送了邮件，接收方可以做其他事情，并断开连接并重新打开管道，但是msg最终是空的。如果我在调试器中将其停止并发送某些内容，则msg的值将获得“ 0x0处的内存....”，我将其解释为某种指针，但是正如您probalby注意到的那样，管道有限。

Here我发现了一个同步管有效的很好的例子。我将管道的创建更改为接收方，但这并不难。我找到了一些异步（重叠）管道here的示例，这些示例也很棒，但让我面临了我现在面临的问题。

从重叠的管道中读取数据仍然是win32file.ReadFile的一项任务，还是我想念的其他东西？

非常感谢您！

Answer 1

发布者的代码和接受的答案无法处理ERROR_IO_PENDING。不幸的是，我在其他任何地方都找不到很好的Python示例，因此我花了一些时间进行研究。

根据您的环境进行修改，连接到管道服务器，然后调用receive（）。它将从管道返回完整的消息，或者无。

如果要观看代码的工作原理，请将read_buf的大小设置为一个较小的值（例如64个字节），并添加一些日志记录语句。

对于文件和套接字，相同的代码应该可以很好地工作（经过轻度修改）。


import win32file
import win32pipe
import winerror
import pywintypes

class pipe_comms:
    def __init__(self):
        self.pipe_open = False
        self.pipe_handle = None
        self.pipe_name = r”\\.\pipe\your_pipe”
        self.read_msg = None
        self.overlapped = None
        self.read_buf = win32file.AllocateReadBuffer(4096)

    def connect(self):
        if not self.pipe_open:
            try:
                self.pipe_handle = win32file.CreateFile(self.pipe_name
                    win32file.GENERIC_READ | win32file.GENERIC_WRITE,
                    0, None, win32file.OPEN_EXISTING,
                    win32file.FILE_FLAG_OVERLAPPED, None)
                win32pipe.SetNamedPipeHandleState(self.pipe_handle, 
                    win32pipe.PIPE_READMODE_MESSAGE, None, None)
                self.pipe_open = True
                self.read_msg = None
            except pywintypes.error as e:
                self.handle_error(e.args[0])
                return False
        return True

    def receive(self):
        try:
            result = self.receive_overlapped()
            if result == winerror.ERROR_SUCCESS:
                fullMsg = self.read_msg
                self.read_msg = None
                return fullMsg
            elif result == winerror.ERROR_IO_PENDING:
                return None
            else:
                self.handle_error(result)
        except pywintypes.error as e:
            self.handle_error(e.args[0])
            return None

    def receive_overlapped(self):
        if self.overlapped:
            try:
                bytes_read = win32file.GetOverlappedResult(self.pipe_handle, self.overlapped, 0)
                self.read_msg += bytes(self.read_buf[:bytes_read])
                self.overlapped = None
                return winerror.ERROR_SUCCESS
            except pywintypes.error as e:
                result = e.args[0]
                if result = winerror.ERROR_MORE_DATA:
                    bytes_read = len(self.read_buf)
                    self.read_msg += bytes(self.read_buf[:bytes_read])
                    # fall thru to issue new ReadFile
                else:
                    # ERROR_IO_PENDING is normal, anything else is not
                    return result 
        else:
            self.read_msg = bytes()
            self.overlapped = pywintypes.OVERLAPPED()

        result, data = win32file.ReadFile(self.pipe_handle, self.read_buf, self.overlapped)
        while True:
            if result = winerror.ERROR_MORE_DATA:
                bytes_read = len(pipe_data)
                self.read_msg = bytes(data[:bytes_read])
                result, data = win32file.ReadFile(self.pipe_handle, self.read_buf, self.overlapped)
                continue
            elif result == winerror.ERROR_SUCCESS:
                bytes_read = win32file.GetOverlappedResult(self.pipe_handle, self.overlapped, 0)
                self.read_msg = bytes(data[:bytes_read])
                self.overlapped = None
            return result

    def handle_error(self, result):
        reset_pipe = False
        if result == winerror.ERROR_BROKEN_PIPE:
            win32pipe.DisconnectNamedPipe(self.pipe_handle)
            reset_pipe = True
        elif result == winerror.ERROR_NO_DATA:
            reset_pipe = True
            
        if reset_pipe:
            self.pipe_handle = None
            self.pipe_open = False
            self.read_msg = None
            self.overlapped = None

Answer 2

我找到了解决方案，并希望分享它，以防万一其他人对这个问题之以鼻。事实证明，msg是一个“ memoryview”对象，它的数据可以通过bytes(msg)公开。{p}

我的ReadFile命令也存在问题，因为缓冲区必须大于0才能实现任何目的。现在，它逐个读取每个字节，并将它们加到一个字符串中。这在性能上可能不是很好，但是它对我有用，并且解决了如果消息短于缓冲区长度则必须削减结尾的问题。

msg = ''
rtnvalue, data = win32file.ReadFile(pipe, 1, pywintypes.OVERLAPPED())
while rtnvalue == 234:
    msg = msg + bytes(data).decode('ASCII') 
    rtnvalue, data = win32file.ReadFile(pipe, 1, pywintypes.OVERLAPPED())
if rtnvalue == 0: #end of stream is reached
    msg = msg + bytes(data).decode('ASCII')
return msg

在Python 3.7中使用和重叠命名管道

2 个答案: