訊息很大，您可能需要考慮較小的訊息。node-ipc和swift(OSX)

我有一個節點應用程式正在嘗試使用 unix 套接字與 swift 應用程式通信。我使用以下代碼和 node-ipc 每 3 秒廣播一條訊息：

const ipc = require('node-ipc').default;       

// Run IPC server for testing
const first = "FIRST";
const second = "SECOND";
const ipcSocketPath = `/tmp/${ipcAppId}`;

async function setupCoreCommunicationIpc() {
    await new Promise((resolve) => {
        ipc.serve(ipcSocketPath, () => {
            ipc.server.on('ping', (data, socket) => {
                ipc.server.emit(socket, 'pong');
            });

            return resolve(true);
        });
        ipc.server.start();
    });
}


function sendMessage(message, payload = {}) {
    ipc.server.broadcast(message, { ...payload, "valueOne": first, "valueTwo": seconds });
}


(async () => {
    try {
        await setupCoreCommunicationIpc()
    } catch (e) {
        // Deal with the fact the chain failed
    }
    // `text` is not available here
})();

setInterval(async () => {
    await sendMessage("first:message", {core_id: ipcAppId, app_id: ipcAppId, message_id: 5})
}, 3000);

swift 上的代碼有點復雜。但我能夠連接到 unix 套接字并接收訊息。問題是 AckMessage 的發送。我嘗試了不同的方法來發送訊息，但它不起作用。這是swift中的代碼：

func startSocketStack(valueOne: String, valueTwo: String){
    let MTU = 65536
    let path = "/tmp/\(valueTwo)"
    print("starting socket at: %\(path)%")
    
    let client = socket(AF_UNIX, SOCK_STREAM, 0)
    var address = sockaddr_un()
    //address.sun_family = UInt8(AF_UNIX)
    address.sun_family = sa_family_t(AF_UNIX)
    //address.sun_len = UInt8(MemoryLayout<sockaddr_un>.size)
    address.sun_len = UInt8(MemoryLayout<UInt8>.size   MemoryLayout<sa_family_t>.size   path.utf8.count   1)
    strlcpy(&address.sun_path.0, path, MemoryLayout.size(ofValue: address.sun_path))
    
    var adressUnwrap = address
    withUnsafePointer(to: &adressUnwrap) {
        $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
            let connection = connect(client, $0, socklen_t(address.sun_len))
            if (connection != 0) {
                print("startSocket: could not connect to socket at \(path)")
            }
        }
    }
    
    var buffer = UnsafeMutableRawPointer.allocate(byteCount: MTU,alignment: MemoryLayout<CChar>.size)
    while(true) {
        let readResult = read(client, &buffer, MTU)
        if (readResult == 0) {
            break;  // end of file
        } else if (readResult == -1) {
            print("Error reading form client\(client) - \(errno)")
            break;  // error
        } else {
            let strResult = withUnsafePointer(to: &buffer) {
                $0.withMemoryRebound(to: CChar.self, capacity: MemoryLayout.size(ofValue: readResult)) {
                    String(cString: $0)
                }
            }
            print("Received form client(\(client)): §\(strResult)§")
            print("§\(strResult)§")
            let trimmedString = strResult.components(separatedBy: .whitespacesAndNewlines).joined()
            print("§\(trimmedString)§")

          
            struct Message: Decodable {
                let type: String
                let data: MessageData
                
                struct MessageData: Decodable {
                    var valueOne: String
                    var valueTwo: String
                    var message_id: String
                }
            }
            
            struct AckMessage: Encodable {
                let type: String
                let data: Bool
            }
            
            do {
                let jsonMessage = trimmedString.components(separatedBy: "}")[0]   "}"   "}"
                let jsonData = jsonMessage.trimmingCharacters(in: CharacterSet.newlines).data(using: .utf8)!
                let receivedMessage: Message = try JSONDecoder().decode(Message.self, from: jsonData)
                let messageId = receivedMessage.data.message_id
                let ackMessage = AckMessage(type: messageId, data: true)
                let jsonAckMessage = try JSONEncoder().encode(ackMessage)
                let delimiter = #"\f"#.bytes
                let jsonAckMessageWithDelimiter = jsonAckMessage   delimiter
                print("jsonAckMessageWithDelimiter")
                print(jsonAckMessageWithDelimiter)

                
                
                // first attempt
                do {
                    try jsonAckMessageWithDelimiter.withUnsafeBytes() { [unowned self] (buffer: UnsafeRawBufferPointer) throws -> Int in
                        let buffer = buffer.baseAddress!
                        print(buffer)
                        let bufSize = jsonAckMessageWithDelimiter.count
                        print(bufSize)
                        
                        var sent = 0
                        var sendFlags: Int32 = 0
                        while sent < bufSize {

                            var s = 0
                            s = send(client, buffer.advanced(by: sent), Int(bufSize - sent), sendFlags)
                            if s <= 0 {

                                if errno == EAGAIN{

                                    // We have written out as much as we can...
                                    return sent
                                }
                            }
                            sent  = s
                        }
                        return sent
                    }
                } catch {
                    print(error)
                }
                
                
                // second attempt
                jsonAckMessageWithDelimiter.withUnsafeBytes {
                    guard let pointer = $0.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
                      return
                    }
                    write(client, pointer, jsonAckMessageWithDelimiter.count)
                }
            } catch {
                print("Error on received message \(error)")
            }
        }
    }
}

在我的節點應用程式中，我無法收到 AckMessage，因為我收到以下錯誤：

Messages are large, You may want to consider smaller messages.

現在根據我在 Windows 和 Linux 上的經驗，我知道這\f是應該指示訊息結尾的分隔符。我在我的 json 末尾發送它，但不知何故無法識別。

可能是什么問題呢？分隔符錯了嗎？緩沖區大小有問題嗎？

在記錄我發送的內容時，它說它已按預期發送了所有 61 個位元組。

uj5u.com熱心網友回復：

對于任何有這個問題的人來說，使用"\u{000C}"代替"\f"是解決方案。

標籤：节点.js 迅速 插座 Unix 套接字 节点ipc

上一篇：套接字連接失敗時如何不崩潰

下一篇：如何處理廣播訊息？