Golang Database.GridFS方法代码示例

// New returns a new Storage that stores blobs in the
// given database. The collections created will be given names with the
// given prefix.
func New(db *mgo.Database, collectionPrefix string) *Storage {
	s := &Storage{
		fs: db.GridFS(collectionPrefix),
	}
	// TODO check error
	s.fs.Files.EnsureIndex(mgo.Index{
		Key:    []string{"filename"},
		Unique: true,
	})
	return s
}

func getMongoFileContent(ctx *goproxy.ProxyCtx, db mgo.Database, objId bson.ObjectId) (file *mgo.GridFile, err error) {
	ctx.Logf("db: %+v", db)
	file, err = db.GridFS("fs").OpenId(objId)

	if err != nil {
		return file, err
		if err == mgo.ErrNotFound {
		}
	}
	//defer file.Close()

	return file, err
}

// Store file in MongoDB GridFS
func saveFileToMongo(db mgo.Database, objId bson.ObjectId, contentType string, openFile io.Reader, fileName string, ctx *goproxy.ProxyCtx) {
	ctx.Logf("db: %+v", db)
	mdbfile, err := db.GridFS("fs").Create(fileName)
	if err == nil {
		mdbfile.SetContentType(contentType)
		mdbfile.SetId(objId)
		ctx.Logf("Copying to: %s", fileName)
		_, err = io.Copy(mdbfile, openFile)
		if err != nil {
			ctx.Logf("Unable to copy to mongo: %s - %v", fileName, err)
		}
		ctx.Logf("Done copying, closing")
		err = mdbfile.Close()
		if err != nil {
			ctx.Logf("Unable to close copy to mongo")
		}
		ctx.Logf("MongoDB body file saved")
	}
}

func get(w http.ResponseWriter, req *http.Request, vars martini.Params, db *mgo.Database) {
	// validate _id
	if !bson.IsObjectIdHex(vars["_id"]) {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	// define main variables
	_id := bson.ObjectIdHex(vars["_id"])
	query := db.C(vars["coll"] + ".files").FindId(_id)
	meta := bson.M{}
	err := query.One(&meta)

	// found file or not
	if err != nil {
		if err.Error() == "not found" {
			w.WriteHeader(http.StatusNotFound)
		} else {
			w.WriteHeader(http.StatusBadRequest)
			w.Write([]byte(err.Error()))
		}
		return
	}

	uploadDate := meta["uploadDate"].(time.Time)
	contentType := meta["contentType"].(string)
	fileName := meta["filename"].(string)

	req.ParseForm()
	head := w.Header()
	head.Add("Accept-Ranges", "bytes")
	head.Add("ETag", vars["_id"]+"+"+req.URL.RawQuery)
	head.Add("Date", uploadDate.Format(FORMAT))
	head.Add("Last-Modified", uploadDate.Format(FORMAT))
	// Expires after ten years :)
	head.Add("Expires", uploadDate.Add(87600*time.Hour).Format(FORMAT))
	head.Add("Cache-Control", "public, max-age=31536000")
	head.Add("Content-Type", contentType)
	if _, dl := req.Form["dl"]; (contentType == "application/octet-stream") || dl {
		head.Add("Content-Disposition", "attachment; filename='"+fileName+"'")
	}

	// already served
	if h := req.Header.Get("If-None-Match"); h == vars["_id"]+"+"+req.URL.RawQuery {
		w.WriteHeader(http.StatusNotModified)
		w.Write([]byte("304 Not Modified"))
		return
	}

	// get file
	file, err := db.GridFS(vars["coll"]).OpenId(_id)
	defer file.Close()
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte(err.Error()))
		return
	}
	// check to crop/resize
	cr, isCrop := req.Form["crop"]
	scr, isSCrop := req.Form["scrop"]
	rsz, isResize := req.Form["resize"]

	isIn := ^in([]string{"image/png", "image/jpeg"}, file.ContentType()) != 0

	if isCrop && isIn && cr != nil {
		parsed, _ := parseParams(cr[0])
		if parsed != nil {
			crop(w, file, parsed)
			return
		}
	} else if isSCrop && isIn && scr != nil {
		parsed, _ := parseParams(scr[0])
		if parsed != nil {
			smartCrop(w, file, parsed)
			return
		}

	} else if isResize && isIn && rsz != nil {
		parsed, _ := parseParams(rsz[0])
		if parsed != nil {
			resize(w, file, parsed)
			return
		}
	} else {
		io.Copy(w, file)
	}

}

func post(w http.ResponseWriter, req *http.Request, vars martini.Params, db *mgo.Database) {
	formFile, formHead, err := req.FormFile("field")
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte("400 Bad Request"))
		return
	}
	defer formFile.Close()

	//remove any directory names in the filename
	//START: work around IE sending full filepath and manually get filename
	itemHead := formHead.Header["Content-Disposition"][0]
	lookfor := "filename=\""
	fileIndex := strings.Index(itemHead, lookfor)

	if fileIndex < 0 {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte("400 Bad Request"))
		return
	}

	filename := itemHead[fileIndex+len(lookfor):]
	filename = filename[:strings.Index(filename, "\"")]

	slashIndex := strings.LastIndex(filename, "\\")
	if slashIndex > 0 {
		filename = filename[slashIndex+1:]
	}

	slashIndex = strings.LastIndex(filename, "/")
	if slashIndex > 0 {
		filename = filename[slashIndex+1:]
	}
	//END: work around IE sending full filepath

	// GridFs actions
	file, err := db.GridFS(vars["coll"]).Create(filename)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte("400 Bad Request"))
		return
	}
	defer file.Close()

	io.Copy(file, formFile)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte("400 Bad Request"))
		return
	}

	b := make([]byte, 512)
	formFile.Seek(0, 0)
	formFile.Read(b)

	file.SetContentType(http.DetectContentType(b))
	file.SetMeta(req.Form)
	err = file.Close()

	_id, _ := file.Id().(bson.ObjectId)

	// json response
	field := "/" + _id.Hex() + "/" + filename
	if !conf.TailOnly {
		field = "/" + vars["coll"] + field
	}

	bytes, _ := json.Marshal(map[string]interface{}{
		"error": err,
		"field": field,
	})
	w.Write(bytes)
}