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

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 les données de l'événement seulement donnez-moi la mémoire tampon. Ainsi est-il possible de capturer le flux lui-même et de le pousser à S3?

InformationsquelleAutor Dave Long | 2011-10-22
  1. 20

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

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

    Formidable 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;
    }

    Puis 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 le req.write(data) return false signifie que le buffer est plein. Vous devez mettre en pause le Formidable analyseur. Lorsque vous obtenez une drain cas de Knox stream vous devriez reprendre Formidable.

    InformationsquelleAutor kgilpin
  2. 6

    Utilisation le multipartisme à la place. Il prend en charge ce genre de streaming comme vous le souhaitez. Il a même un exemple de streaming directement sur s3: https://github.com/superjoe30/node-multiparty/blob/master/examples/s3.js

    • j'étais donc coincé et de passer à multipartite résolu ce
    InformationsquelleAutor andrewrk
  3. 0

    Dans un Express middleware, j'utilise formidable avec PassThrough de flux de télécharger un fichier à S3 (dans mon cas, pour Minio qui est S3 compatible par le biais de Minio SDK; et je crois qu'il travaille pour AWS S3 trop avec le même Minio SDK)

    Voici un exemple de code.

    const formidable = require('formidable')
const { PassThrough } = require('stream')

const form = new formidable.IncomingForm()
const pass = new PassThrough()

const fileMeta = {}
form.onPart = part => {
  if (!part.filename) {
    form.handlePart(part)
    return
  }
  fileMeta.name = part.filename
  fileMeta.type = part.mime
  part.on('data', function (buffer) {
    pass.write(buffer)
  })
  part.on('end', function () {
    pass.end()
  })
}
form.parse(req, err => {
  if (err) {
    req.minio = { error: err }
    next()
  } else {
    handlePostStream(req, next, fileMeta, pass)
  }
})

    Et handlePostStream ressemble à ci-dessous, pour votre référence:

    const uuidv1 = require('uuid/v1')

const handlePostStream = async (req, next, fileMeta, fileStream) => {
  let filename = uuidv1()

  try {
    const metaData = {
      'content-type': fileMeta.type,
      'file-name': Buffer.from(fileMeta.name).toString('base64')
    }

    const minioClient = /* Get Minio Client*/
    await minioClient.putObject(MINIO_BUCKET, filename, fileStream, metaData)

    req.minio = { post: { filename: `${filename}` } }
  } catch (error) {
    req.minio = { error }
  }
  next()
}

    Vous pouvez trouver le code source sur GitHub, et ses tests unitaires trop.

    InformationsquelleAutor Yuci
  4. -2

    Il n'existe aucun moyen pour vous de capturer le flux, car les données doivent être traduits par Formidable. Le buffer vous êtes donné est le contenu du fichier en segments de buffer.length: ce 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 incertain au sujet 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.

    InformationsquelleAutor Femi