Accéder au flux de fichier brut à partir d'un téléchargement de fichier formidable par un nœud

Question

Je suis entrain de créer une application qui ne prend que quelques téléchargements de fichiers et de les envoyer tout droit jusqu'à S3. Je préfère ne pas même avoir la tmp fichier sur mon serveur, donc je suis en utilisant le Knox module et aimerait profiter de la crue de flux de Formidable et de l'envoyer sur Knox à S3. J'ai fait quelque chose de similaire à l'aide de Knox pour télécharger un fichier à l'aide de ce code:

knox.downloads.get(widget.download).on('response',function(sres){
    res.writeHead(200, {
        'Content-Type':'application/zip',
        'Content-Length': sres.headers['content-length'],
        'Content-Disposition':'attachment; filename=' + widget.download
    });
    util.pump(sres, res);
}).end();

Maintenant, je voudrais faire quelque chose de similaire dans la direction oppos (téléchargement de Fichier depuis le navigateur à S3).

Jusqu'à présent, j'ai écrit un gestionnaire d'événement pour capturer chaque morceau de données à partir du fichier car il est en cours de téléchargement:

var form = new formidable.IncomingForm();
form.onPart = function(part){
    if(!part.filename){
        form.handlePart(part);
    }else{
        if(part.name == 'download'){
            // Upload to download bucket
            controller.putDownload(part);
        }else{
            // Upload to the image bucket
            controller.putImage(part);
        }
        //res.send(sys.inspect(part));
    }
}
form.parse(req, function(err, fields, files){
    if(err){
        res.json(err);
    }else{
        res.send(sys.inspect({fields:fields, files:files}), {'content-type':'text/plain'});
        //controller.createWidget(res,fields,files);            
    }
});


controller.putDownload = function(part){
    part.addListener('data', function(buffer){
        knox.download.putStream(data,part.filename, function(err,s3res){
            if(err)throwError(err);
            else{
                console.log(s3res);
            }
        });
    })
    knox.downloads.putStream(part, part.filename, function(err,s3res){

        if(err)throwError(err);
        else{
            console.log(s3res);
        }
    });
}

Mais l'événement de données seulement donnez-moi la mémoire tampon. Ainsi est-il possible de capturer le flux lui-même et de le pousser à S3?

Answer 1

Ce que vous voulez faire est de remplacer l' Form.onPart méthode:

IncomingForm.prototype.onPart = function(part) {
  // this method can be overwritten by the user
  this.handlePart(part);
};

Formidable, le comportement par défaut est d'écrire la partie d'un fichier. Vous ne voulez pas que. Vous souhaitez gérer la partie " événements d'écrire pour le knox télécharger. Ceci pour commencer:

form.onPart = function(part) {
    if (!part.filename) {
        // let formidable handle all non-file parts
        form.handlePart(part);
        return;
    }

Ensuite, ouvrez le knox et de demande de la poignée de la pièce brute des événements de vous-même:

part.on('data', function(data) {
    req.write(data);
});
part.on('end', function() {
    req.end();
});
part.on('error', function(err) {
    // handle this too
});

Comme un bonus, si l' req.write(data) return false signifie que le buffer est plein. Vous devez mettre en pause le Formidable analyseur. Lorsque vous obtenez une drain événement à partir de la Knox stream vous devriez reprendre Formidable.

Answer 2

Utilisez plusieurs parties à la place. Il supporte ce type de streaming comme vous le souhaitez. Il a même un exemple de diffusion directe sur s3: https://github.com/superjoe30/node-multiparty/blob/master/examples/s3.js

Answer 3

Il n'existe aucun moyen pour vous de capturer le flux, car les données doivent être traduits par Formidable. L' buffer vous êtes donné est le contenu du fichier en blocs d' buffer.length: cela pourrait être un problème parce qu'en regardant Formidable de docs il semble que jusqu'à ce que le fichier soit complètement chargé, il ne peut pas fiable rapport de la taille du fichier et de Knox put méthode pourrait avoir besoin de cela.

Jamais utilisé Knox de cette façon avant, mais vous pourriez avoir de la chance avec quelque chose comme ceci:

controller.putDownload = function(part){
    var req = knox.download.put(part.filename, {
      'Content-Type': 'text/plain'
    });
    part.addListener('data', function(buffer){
    req.write(buffer);
    });
    req.on('response', function(res){
       // error checking
    });
    req.end();
}

Un peu de doute à propos de la vérification de la réponse bits, mais....voyez si vous pouvez fouetter que dans la forme. Aussi, le Streaming d'un flux d'octets de la demande à la S3 avec knox sur node.js a aussi un article qui peut être utile pour vous.