Der Zugriff auf die raw-Datei-stream von einer Knoten-gewaltige-Datei hochladen

Ich bin erstellen einer Anwendung, die einige Datei-uploads und senden Sie Sie gerade bis zum S3. Ich würde es vorziehen, nicht auch die tmp-Datei auf meinem server, also ich bin mit dem Knox-Modul und würde gern die raw-stream von Gewaltigen und senden Sie es über Knox auf dem S3. Ich habe etwas ähnliches gemacht mit Knox um eine Datei herunterzuladen, mit diesem 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();

Nun würde ich gerne etwas ähnliches in die entgegengesetzte Richtung (Datei-upload aus dem browser-S3).

So weit ich geschrieben habe, einen event-handler zu erfassen, jedes Stück von Daten aus der Datei, wie es hochgeladen wird:

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

Aber das Ereignis data nur gib mir den Puffer. So ist es möglich zu erfassen, den Strom selbst und schieben Sie es auf S3?

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

    Was Sie tun möchten, ist das überschreiben der Form.onPart Methode:

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

    Gewaltige Standard-Verhalten ist zu schreiben, der Teil einer Datei. Das wollen Sie nicht. Sie behandeln möchten, die 'part' - Ereignisse zu schreiben, die knox herunterladen. Beginnen Sie mit diesem:

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

    Dann öffnen Sie die knox-Anforderung und zum Umgang mit den raw-Teil Veranstaltungen selbst:

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

    Als bonus, wenn die req.write(data) return false bedeutet, dass die sende-Puffer voll ist. Sie sollten angehalten werden, die Gewaltige parser. Wenn Sie einen drain Ereignis aus der Knox-stream sollte man fortsetzen Gewaltig.

    InformationsquelleAutor kgilpin
  2. 6

    Verwenden mit mehreren Teilnehmern statt. Es unterstützt diese Art von streaming-wie Sie wollen. Es hat sogar ein Beispiel von streaming direkt auf s3: https://github.com/superjoe30/node-multiparty/blob/master/examples/s3.js

    • ich war so festgefahren und den Umstieg auf eine Mehrparteien-Problem gelöst
    InformationsquelleAutor andrewrk
  3. 0

    In einem Express-middleware, die ich verwenden formidable zusammen mit PassThrough zu streamen-eine Datei hochladen, S3 (in meinem Fall, zu Minio die S3 kompatibel durch Minio-SDK; und ich glaube, es funktioniert für AWS-S3, auch mit der gleichen Minio SDK)

    Hier ist der Beispielcode.

    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)
  }
})

    Sowie handlePostStream sieht aus wie unten für Ihre Referenz:

    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()
}

    Finden Sie der source-code auf GitHub, und seine unit-tests zu.

    InformationsquelleAutor Yuci
  4. -2

    Gibt es keine Möglichkeit für Sie zu erfassen stream, da die Daten übersetzt werden, die durch Gewaltige. Die buffer Sie gegeben sind, ist der Inhalt der Datei wird in Blöcken von buffer.length: das könnte ein problem sein, weil der Blick auf die Gewaltige docs scheint es, dass, bis die Datei vollständig hochgeladen, es kann nicht zuverlässig melden die Größe der Datei und Knox ' put Methode könnte das brauchen.

    Nie benutzt Knox auf diese Weise vor, aber haben Sie vielleicht mit etwas Glück so etwas wie dieses:

    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();
}

    Etwas unsicher über die Antwort, die überprüfung bits, aber....sehen Sie, wenn Sie können Peitsche in Form. Auch, Streaming ein Oktett-stream von der Anfrage bis S3 mit knox auf node.js hat auch ein Dokument verfasst, die für Sie nützlich sein kann.

    InformationsquelleAutor Femi
Schreibe einen Kommentar