Question

我正在尝试实现一个通过套接字发送和接收文件的协议。协议已指定，我无法更改。

我是NodeJs的新手，这就是我试图实现它的方式。

我会写一个双工流，并将管道文件写入其中。然后将其传输到套接字以发送数据。

我应该读到这里的混乱，以及在哪里写这个。如何知道读取文件已经完成，以及如何告诉socket它已完成。文档对我来说不是很清楚，谷歌搜索更加混乱：）

任何帮助都将不胜感激。

P.S。我回家后会添加自己的样品，我现在还没有。

修改

在@ MattHarrison回答之后，我将代码更改为：

var stream = require('stream');
var util = require('util');
var bufferpack = require('bufferpack');
var fs = require('fs');
var net = require('net');

var MyProtocolStream = function () {

    this.writtenHeader = false;            // have we written the header yet?
    stream.Transform.call(this);
};

util.inherits(MyProtocolStream, stream.Transform);

MyProtocolStream.prototype._transform = function (chunk, encoding, callback) {

    if (!this.writtenHeader) {
        this.push('==== HEADER ====\n');  // if we've not, send the header first
    }

    // Can this function be interrupted at this very line?
    // Then another _transform comes in and pushes its own data to socket
    // Corrupted data maybe then?
    // How to prevent this behavior? Buffering whole file before sending?

    var self = this;
    // I put a random timeout to simulate overlapped calls
    // Can this happen in real world?
    setTimeout(function () {
        self.push(chunk);  // send the incoming file chunks along as-is
        callback();
    }, Math.random()*10);
};

MyProtocolStream.prototype._flush = function (callback) {

    this.push('==== FOOTER ====\n');      // Just before the stream closes, send footer
    callback();
};

var file = '/tmp/a';

var server = net.createServer(function (sck) {
    sck.addr = sck.remoteAddress;
    console.log('Client connected - ' + sck.addr);
    fs.createReadStream('/tmp/a').pipe(new MyProtocolStream()).pipe(sck);
    fs.createReadStream('/tmp/b').pipe(new MyProtocolStream()).pipe(sck);
    fs.createReadStream('/tmp/c').pipe(new MyProtocolStream()).pipe(sck);
    sck.on('close', function () {
        console.log('Client disconnected - ' + this.addr);
    })
});

server.listen(22333, function () {
    console.log('Server started on ' + 22333)
});

请参阅_transform中的评论。

Answer 1

我不确定您要尝试实施的协议的具体细节，但以下内容应该为您提供一个可以适应您需求的良好模式。

我的虚构协议

当客户端套接字连接到我的TCP服务器时，我想向他们发送一个文件。但首先我要发送标题。在文件的末尾，在流结束之前，我还想发送一个标头。因此写入套接字的数据如下所示：

==== HEADER ====
[FILE CONTENTS]
==== FOOTER ====

实施转化流

我想要做的就是转换来自可读流的数据。注意转换是此处的关键字。我可以使用Transform流。

创建变换流时，您可以覆盖两个方法：_transform和_flush。调用_transform时，每个chunk都会显示可读流。您可以更改数据，缓冲数据或其他任何内容。在可读的所有数据完成后立即调用_flush。你可以在这里做更多的清理，或者写出最后一点数据。

var Stream = require('stream');
var Util = require('util');

var MyProtocolStream = function () {

    this.writtenHeader = false;            // have we written the header yet?
    Stream.Transform.call(this);
};

Util.inherits(MyProtocolStream, Stream.Transform);

MyProtocolStream.prototype._transform = function (chunk, encoding, callback) {

    if (!this.writtenHeader) {
        this.push('==== HEADER ====\n');  // if we've not, send the header first
        this.writtenHeader = true;
    }
    this.push(chunk);                     // send the incoming file chunks along as-is
    callback();
};

MyProtocolStream.prototype._flush = function (callback) {

    this.push('==== FOOTER ====\n');      // Just before the stream closes, send footer 
    callback();
};

使用MyProtocolStream

所以现在我有一个做我想要的流，我可以通过我的自定义Transform流管道文件（或任何可读的流）到任何其他可写流（例如套接字）。

var Fs = require('fs');
var Net = require('net');

var server = Net.createServer(function (socket) {

    Fs.createReadStream('./example.txt')
        .pipe(new MyProtocolStream())
        .pipe(socket);
});

server.listen(8000);

测试

我可以通过向example.txt添加一些内容来测试它：

This is a line
This is another line
This is the last line

我可以启动我的服务器，然后用telnet / nc连接：

$ telnet 127.0.0.1 8000
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
==== HEADER ====
This is a line
This is another line
This is the last line
==== FOOTER ====
Connection closed by foreign host.

那么Duplex流呢？

双工流是嵌入其中的两个流。数据来自一个，你将完全不同的数据写入另一个。它用于与另一个实体（例如TCP套接字）进行双向通信的地方。在此示例中，我们不需要双工流，因为数据仅在一个方向上流动：

file -> MyProtocolStream -> socket

了解更多

正如Meir在另一个答案中指出的那样，Substack's stream handbook是流的规范（和最佳）资源以及官方文档。如果您仔细阅读并自己实施示例，您将学习有关流的所有知识。

在单个套接字上串行发送多个文件

如果您想将多个这些Transforms流的输出写入单个可写端，pipe()将不适合您。一旦EOF来自单个流，上游可写（套接字）也将被关闭。在这种情况下，也无法保证数据事件的排序。因此，您需要通过监听data / end事件来手动聚合流，开始在另一个流完成后读取一个流：

var server = Net.createServer(function (socket) {

    var incoming1 = Fs.createReadStream('./example.txt')
            .pipe(new MyProtocolStream());

    var incoming2 = Fs.createReadStream('./example.txt')
            .pipe(new MyProtocolStream());

    var readStream = function (stream, callback) {

        stream.on('data', socket.write.bind(socket));
        stream.on('end', callback);
    };

    readStream(incoming1, function () {

        readStream(incoming2, function () {

            socket.end();
        });
    });
});

如果你是嵌套的回调函数，你也可以使用promises：

var server = Net.createServer(function (socket) {

    var incoming1 = Fs.createReadStream('./example.txt')
            .pipe(new MyProtocolStream());

    var incoming2 = Fs.createReadStream('./example.txt')
            .pipe(new MyProtocolStream());

    var incoming3 = Fs.createReadStream('./example.txt')
            .pipe(new MyProtocolStream());

    var readStream = function (stream) {
        return new Promise(function (resolve, reject) {
            stream.on('data', socket.write.bind(socket));
            stream.on('end', resolve);
        });
    };

    readStream(incoming1)
    .then(function () {
        return readStream(incoming2);
    })
    .then(function () {
        return readStream(incoming3);
    })
    .then(function () {
        socket.end();
    });
});

Answer 2

这是great resource on streams。

对于套接字使用，当您发送/获取套接字消息时，您发送类型和有效负载。因此，您的常规套接字流可以发送类型为＆＃39; file_data＆＃39;的消息。在您要发送数据的同时发送内容，最后发送类型为＆＃39; eof＆＃39; （对于文件末尾），有空载荷。

对NodeJs中的Stream实现感到困惑

2 个答案: