javascript - example - Almacenamiento del flujo de datos desde la solicitud POST en GridFS, express, mongoDB, node.js

gridfsbucket mongoose

Question

Estoy tratando de averiguar cómo puedo publicar una imagen directamente en GridFS sin almacenarla en ningún lugar en el servidor como un archivo temporal primero.

Estoy usando Postman (chrome ext.) Para publicar un archivo, y me las arreglo para almacenar esta publicación como un archivo usando:

req.pipe(fs.createWriteStream(''./test.png''));

También puedo almacenar directamente en GridFS desde un readStream cuando el readStream se crea desde un archivo en el servidor. (ver código)

Tengo los siguientes archivos, saveFromReq.js , que escucha el POST y, básicamente, lo pasa al savePic.js .

saveFromReq.js:

var express = require(''express'');
var app = express();
var savePic = require(''./savePic'');
var fs = require(''fs'');
var GridStore = require(''mongodb'').GridStore;
var pic = ''./square.png'';
var picID;
//When the following
//var pic = fs.createReadStream(''./square.png'', {autoClose: true});
//is not commented out, and ''req'' is replaced with ''pic'' in the savePic function,
//the file square.png is stored correctly to GridFS
app.post(''/picture'', function(req, res){
savePic(req, function(id){});
res.writeHead(200, {''Content-Type'': ''text'' });
res.end("Sucsess!/n");
});
app.listen(process.env.PORT || 3413);

savePic.js:

var savePic = function(req, callback){
var Db = require(''mongodb'').Db,
MongoClient = require(''mongodb'').MongoClient,
Server = require(''mongodb'').Server,
ReplSetServers = require(''mongodb'').ReplSetServers,
ObjectID = require(''mongodb'').ObjectID,
Binary = require(''mongodb'').Binary,
GridStore = require(''mongodb'').GridStore,
Grid = require(''mongodb'').Grid,
Code = require(''mongodb'').Code,
BSON = require(''mongodb'').pure().BSON,
assert = require(''assert'');
fs = require(''fs'');
//When the following
//req.pipe(fs.createWriteStream(''./test.png''));
//is not commented out, the correct image is stored to test.png, and
//the sequence after req.on("data"... starts
//(That sequence does not start at all when this is commented out..)
var fileId = new ObjectID();
var db = new Db(''testDB'', new Server(''localhost'', 27017));
// Establish connection to db
db.open(function(err, db) {
var gridStore = new GridStore(db, ''test'', ''w'');
//open
gridStore.open(function(err, gridStore) {
console.log("opened");
req.on("data", function (data) {
console.log("data recieved");
gridStore.write(data, function (err, gridStore) {
if (err) {
console.log("error writing file");
}
});
});
req.on("end", function () {
gridStore.close(function (err, gridStore) {
if (!err) {
console.log("The file has been stored to database.");
db.close();
}
});
});
req.pipe(gridStore);
});
});
callback(fileId);
};
module.exports = savePic;

Cualquier ayuda sería muy apreciada!

Answer 1

Código completo para insertar el archivo txt en mongodb usando gridfs en nodejs.Esto funciona bien `

var mongoose=require("mongoose");
var gridfsstream=require("gridfs-stream");
var fs=require("fs");
mongoose.connect("mongodb://localhost:27017/testimage");
var conn=mongoose.connection;
gridfsstream.mongo=mongoose.mongo;
conn.once("open",function()
{
console.log("database connected successfully");
var gfs=gridfsstream(conn.db);
var writestream=gfs.createWriteStream({
filename:"danger.txt"
});
fs.createReadStream("sivakasi.txt").pipe(writestream);
writestream.on("close",function(file)
{
console.log(file.filename +"stored successfully into mongodb using gridfs");
});
writestream.on("error",function(file)
{
console.log(file.filename +"not stored into mongodb using gridfs");
});
});
conn.on("error",function()
{
console.log("database not connected try again!!!");
});

`

Answer 2

El código completo para publicar la imagen de html a nodejs almacena esa imagen en mongodb utilizando el sistema gridfs y muestra esa imagen en el servidor. Este código funciona bien.

var express=require("express");
var bodyparser=require("body-parser");
var multer=require("multer");
var app=express();
var upload = multer({ dest: ''/tmp/''});
app.use(bodyparser.urlencoded({extended:false}));
app.post("/uploadimage",upload.single("file"),function(request,response)
{
var mongoose=require("mongoose");
var gridfsstream=require("gridfs-stream");
var fs=require("fs");
mongoose.connect("mongodb://localhost:27017/testimage");
var con=mongoose.connection;
gridfsstream.mongo=mongoose.mongo;
con.once("open",function()
{
console.log("test image database connected successfully");
var gfs=gridfsstream(con.db);
var readstream=fs.createReadStream(request.file.originalname);
var writestream=gfs.createWriteStream({
filename:"mentorpicthree.jpg"
});
readstream.pipe(writestream);
writestream.on("close",function()
{
console.log("image stored in mongodb database successfully");
fs.readFile(request.file.originalname,function(err,data)
{
if(err)
{
response.writeHead(404,{"Content-Type":"text/plain"});
console.log("error");
}
else
{
response.writeHead(200,{"Content-Type":"image/jpg"});
response.end(data);
}
});
});
writestream.on("error",function()
{
console.log("image not stored in mongodb database");
});
});
con.on("error",function()
{
console.log("database not connected try again!!!");
});
});
app.listen(8086,function()
{
console.log("server running on port 8086");
});

<html>
<head>
<title>FILE UPLOAD</title>
</head>
<body>
<p>Ryan Dhal</p>
<form action="http://127.0.0.1:8086/uploadimage" method="POST" enctype="multipart/form-data">
<input type="file" name="file">
<br>
<input type="submit" value="UPLOAD">
</form>
</body>
</html>

Answer 3

Esto me funcionó con la mangosta:

 var gfs = Grid(mongoose.connection.db, mongoose.mongo);
var writeStream = gfs.createWriteStream({
filename: name,
mode: ''w'',
content_type: ''video/mp4''
});
writeStream.on(''close'', function() {
console.log(''close event'');
});
fs.createReadStream(''uploads/'' + name + ''/'' + name + ''.mp4'').pipe(writeStream);
console.log(''stream.write: '' + name + ''/'' + name + ''.mp4'');

Estoy luchando por un par de días para obtener el video en el navegador del lado del cliente. Eso es lo que intenté hasta ahora:

var readstream = gfs.createReadStream({
filename: file.filename
});
readstream.on(''data'', function(data) {
res.write(data);
console.log(data);
});
readstream.on(''end'', function() {
res.end();
});
readstream.on(''error'', function (err) {
console.log(''An error occurred!'', err);
throw err;
});

Mis datos en el lado MongoDB se ve como:

db.fs.chunks.find () {"_id": ObjectId ("5757e76df14741bf0391aaca"), "files_id": ObjectId ("5757e76df14741bf0391aac8"), "n": 0, "datos": ..

Y el tipo de contenido es ''video / mp4'':

el registro en el lado del navegador imprime esto:

Objeto {0: " ", 1: " ", 2: " ", 3: "", 4: "f", 5: "t", 6: "y", 7: "p", 8 : "i", 9: "s", 85003 más ...}

¿Podría alguien salvar mi vida? Espero que no vea mi publicación como no conveniente en este lugar.

Answer 4

Mientras que la respuesta de @ robertklep es correcta, me gustaría agregar algo a su respuesta. Este código muestra cómo puede devolver los metadatos del archivo almacenado.

app.post(''/picture'', function(req, res) {
req.pipe(gfs.createWriteStream({
filename: ''test''
}).on(''close'', function(savedFile){
console.log(''file saved'', savedFile);
return res.json({file: savedFile});
}));
}) 

Answer 5

gridfs-stream hace bastante fácil:

// `gfs` is a gridfs-stream instance
app.post(''/picture'', function(req, res) {
req.pipe(gfs.createWriteStream({
filename: ''test''
}));
res.send("Success!");
});