func uploadBufDemo(r gio.Reader, key, uptoken string) { // @gist uploadBuf var err error var ret io.PutRet var extra = &io.PutExtra{ // Params: params, // MimeType: mieType, // Crc32: crc32, // CheckCrc: CheckCrc, } // ret 变量用于存取返回的信息,详情见 io.PutRet // uptoken 为业务服务器端生成的上传口令 // key 为文件存储的标识 // r 为io.Reader类型,用于从其读取数据 // extra 为上传文件的额外信息,可为空, 详情见 io.PutExtra, 可选 err = io.Put(nil, &ret, uptoken, key, r, extra) if err != nil { //上传产生错误 log.Print("io.Put failed:", err) return } //上传成功,处理返回值 log.Print(ret.Hash, ret.Key) // @endgist }
func UploadReader(reader io.Reader, name string) error { var err error var ret qio.PutRet ACCESS_KEY = "NPfcHtb0e2EH7lCmmJot21MRr0lCel81S-QlUaJF" SECRET_KEY = "6DzF_oVRYhBkq0mqb4txThza_IfQEUey107VXaPq" var policy = qrs.PutPolicy{ Scope: "isaac", } err = qio.Put(nil, &ret, policy.Token(nil), name, reader, nil) return err }
//martini Handler func UploadHandlers() []martini.Handler { var upload = func(fileData FileData, data UploadData, w http.ResponseWriter) { retJsonp := &UploadRetJsonp{MessengerJs: MessengerJs, UpTime: data.UpTime} if strings.ToUpper(data.Dir) != "IMAGE" { retJsonp.Err(w, "dir wrong:"+data.Dir) return } imgFile, err := fileData.ImgFile.Open() if err != nil { retJsonp.Err(w, "ImgFile:"+err.Error()) return } //取得bucket bucket, err := bucketdb.FindByName(data.Bucket) if err != nil { retJsonp.Err(w, "FindByName:"+err.Error()) return } if bucket.Uptoken == "" { if err := bucket.NewUptoken(); err != nil { retJsonp.Err(w, "NewUptoken:"+err.Error()) return } if err := bucket.Save(); err != nil { retJsonp.Err(w, "Save:"+err.Error()) return } } //上传内容到Qiniu var ret qio.PutRet // ret 变量用于存取返回的信息,详情见 qio.PutRet // uptoken 为业务服务器端生成的上传口令 // key:imgName 为文件存储的标识 // r:imgFile 为io.Reader类型,用于从其读取数据 // extra 为上传文件的额外信息,可为空, 详情见 qio.PutExtra, 可选 err = qio.Put(nil, &ret, bucket.Uptoken, fileData.ImgName(), imgFile, nil) if err != nil { bucket.LogErr() retJsonp.Err(w, "Put:"+err.Error()) return } //上传成功,返回给KindEditor //w.Header().Set("Content-type", "application/json") retJsonp.Respose(w, bucket.ImgUrl(ret.Key)) } return []martini.Handler{binding.MultipartForm(FileData{}), binding.Form(UploadData{}), upload} }
func TestUpload(t *testing.T) { var err error var ret io.PutRet var extra = &io.PutExtra{} r, err := os.Open("/users/xxxx/Desktop/psu.jpeg") upToken := upToken("threeperson") err = io.Put(nil, &ret, upToken, "heads/1001/psu.jpeg", r, extra) if err != nil { log.Print("io.Put failed:", err) return } log.Print("result:", ret.Hash, ret.Key) }
func (driver *QiniuDriver) PutFile(key string, data io.Reader, appendData bool) (int64, error) { var err error var ret qio.PutRet var extra = &qio.PutExtra{} putPolicy := rs.PutPolicy{ Scope: driver.bucket, } uptoken := putPolicy.Token(nil) rd := CountReader(data) err = qio.Put(nil, &ret, uptoken, strings.TrimLeft(key, "/"), rd, extra) if err != nil { return 0, err } return int64(rd.Size()), nil }
// 上传到七牛,并返回文件名 func uploadAvatarToQiniu(file io.ReadCloser, contentType string) (filename string, err error) { isValidateType := false for _, imgType := range []string{"image/png", "image/jpeg"} { if imgType == contentType { isValidateType = true break } } if !isValidateType { return "", errors.New("文件类型错误") } filenameExtension := ".jpg" if contentType == "image/png" { filenameExtension = ".png" } // 文件名:32位uuid,不带减号和后缀组成 filename = strings.Replace(uuid.NewUUID().String(), "-", "", -1) + filenameExtension key := "avatar/" + filename ret := new(qiniuIo.PutRet) var policy = rs.PutPolicy{ Scope: "gopher", } err = qiniuIo.Put( nil, ret, policy.Token(nil), key, file, nil, ) if err != nil { return "", err } return filename, nil }
func (this *UploaderLogic) uploadMemoryFile(r gio.Reader, key string) (err error) { this.genUpToken() var ret io.PutRet var extra = &io.PutExtra{ // Params: params, // MimeType: mieType, // Crc32: crc32, // CheckCrc: CheckCrc, } // ret 变量用于存取返回的信息,详情见 io.PutRet // uptoken 为业务服务器端生成的上传口令 // key 为文件存储的标识 // r 为io.Reader类型,用于从其读取数据 // extra 为上传文件的额外信息,可为空, 详情见 io.PutExtra, 可选 err = io.Put(nil, &ret, this.uptoken, key, r, extra) // 上传产生错误 if err != nil { logger.Errorln("io.Put failed:", err) errInfo := make(map[string]interface{}) err = json.Unmarshal([]byte(err.Error()), &errInfo) if err != nil { logger.Errorln("io.Put Unmarshal failed:", err) return } code, ok := errInfo["code"] if ok && code == 614 { err = nil } return } // 上传成功,处理返回值 logger.Debugln(ret.Hash, ret.Key) return }
func (q Qiniu) Store(url string, option *media_library.Option, reader io.Reader) (err error) { var ret qnio.PutRet path := strings.Replace(url, "//"+getEndpoint(option), "", -1) // ret 变量用于存取返回的信息,详情见 io.PutRet // uptoken 为业务服务器端生成的上传口令 // r 为io.Reader类型,用于从其读取数据 // extra 为上传文件的额外信息,可为空, 详情见 io.PutExtra, 可选 err = qnio.Put(nil, &ret, Uptoken, path, reader, nil) if err != nil { //上传产生错误 log.Print("io.Put failed:", err) return } //上传成功,处理返回值 // log.Print(ret.Hash, ret.Key) return }
func Upload(file_name string, rd goio.Reader) (string, error) { var url string if !QiniuEnable { sub := fmt.Sprintf("%d", time.Now().Unix()%31) dir := path.Join(revel.BasePath, "upload", sub) os.MkdirAll(dir, os.ModePerm) fname := fmt.Sprintf("%s%s", time.Now().Format("20060102150405"), file_name) wr, err := os.Create(path.Join(dir, fname)) if err != nil { return "", err } defer wr.Close() if _, err := goio.Copy(wr, rd); err != nil { return "", err } url = fmt.Sprintf("/upload/%s/%s", sub, fname) } else { var ret io.PutRet var extra = &io.PutExtra{} uptoken := QiniuToken(QiniuBucket) if file_name != "" { if err := io.Put(nil, &ret, uptoken, file_name, rd, extra); err != nil { return "", err } } else { if err := io.PutWithoutKey(nil, &ret, uptoken, rd, extra); err != nil { return "", err } } url = fmt.Sprintf("http://%s/%s", QiniuDomain, ret.Key) } return url, nil }
func SaveImageToQiniu(m *models.Image, r goio.ReadSeeker, mime string, filename string, created time.Time, bucketName string) error { var ext string // check image mime type switch mime { case "image/jpeg": ext = ".jpg" case "image/png": ext = ".png" case "image/gif": ext = ".gif" default: ext = filepath.Ext(filename) switch ext { case ".jpg", ".png", ".gif": default: return fmt.Errorf("unsupport image format `%s`", filename) } } // decode image var img image.Image var err error switch ext { case ".jpg": m.Ext = 1 img, err = jpeg.Decode(r) case ".png": m.Ext = 2 img, err = png.Decode(r) case ".gif": m.Ext = 3 img, err = gif.Decode(r) } if err != nil { return err } m.Width = img.Bounds().Dx() m.Height = img.Bounds().Dy() m.Created = created //save to database if err := m.Insert(); err != nil || m.Id <= 0 { return err } m.Token = m.GetToken() if err := m.Update(); err != nil { return err } var key = m.Token //reset reader pointer if _, err := r.Seek(0, 0); err != nil { return err } //save to qiniu var uptoken = utils.GetQiniuUptoken(bucketName) var putRet io.PutRet var putExtra = &io.PutExtra{ MimeType: mime, } err = io.Put(nil, &putRet, uptoken, key, r, putExtra) if err != nil { return err } return nil }
// URL: /upload/image // 编辑器上传图片,接收后上传到七牛 func uploadImageHandler(handler *Handler) { defer dps.Persist() file, header, err := handler.Request.FormFile("editormd-image-file") if err != nil { panic(err) return } defer file.Close() // 检查是否是jpg或png文件 uploadFileType := header.Header["Content-Type"][0] filenameExtension := "" if uploadFileType == "image/jpeg" { filenameExtension = ".jpg" } else if uploadFileType == "image/png" { filenameExtension = ".png" } else if uploadFileType == "image/gif" { filenameExtension = ".gif" } if filenameExtension == "" { handler.renderJson(map[string]interface{}{ "success": 0, "message": "不支持的文件格式,请上传 jpg/png/gif 图片", }) return } // 上传到七牛 // 文件名:32位uuid+后缀组成 filename := strings.Replace(uuid.NewUUID().String(), "-", "", -1) + filenameExtension key := "upload/image/" + filename ret := new(qiniuIo.PutRet) var policy = rs.PutPolicy{ Scope: "gopher", } err = qiniuIo.Put( nil, ret, policy.Token(nil), key, file, nil, ) if err != nil { panic(err) handler.renderJson(map[string]interface{}{ "success": 0, "message": "图片上传到七牛失败", }) return } handler.renderJson(map[string]interface{}{ "success": 1, "url": "http://77fkk5.com1.z0.glb.clouddn.com/" + key, }) }
func (this *Unzipper) Do(req ufop.UfopRequest) (result interface{}, resultType int, contentType string, err error) { //parse command bucket, prefix, overwrite, pErr := this.parse(req.Cmd) if pErr != nil { err = pErr return } //check mimetype if req.Src.MimeType != "application/zip" { err = errors.New("unsupported mimetype to unzip") return } //check zip file length if req.Src.Fsize > this.maxZipFileLength { err = errors.New("src zip file length exceeds the limit") return } //get resource resUrl := req.Src.Url resResp, respErr := http.Get(resUrl) if respErr != nil || resResp.StatusCode != 200 { if respErr != nil { err = errors.New(fmt.Sprintf("retrieve resource data failed, %s", respErr.Error())) } else { err = errors.New(fmt.Sprintf("retrieve resource data failed, %s", resResp.Status)) if resResp.Body != nil { resResp.Body.Close() } } return } defer resResp.Body.Close() respData, readErr := ioutil.ReadAll(resResp.Body) if readErr != nil { err = errors.New(fmt.Sprintf("read resource data failed, %s", readErr.Error())) return } //read zip respReader := bytes.NewReader(respData) zipReader, zipErr := zip.NewReader(respReader, int64(respReader.Len())) if zipErr != nil { err = errors.New(fmt.Sprintf("invalid zip file, %s", zipErr.Error())) return } zipFiles := zipReader.File //check file count zipFileCount := len(zipFiles) if zipFileCount > this.maxFileCount { err = errors.New("zip files count exceeds the limit") return } //check file size for _, zipFile := range zipFiles { fileSize := zipFile.UncompressedSize64 //check file size if fileSize > this.maxFileLength { err = errors.New("zip file length exceeds the limit") return } } //set up host conf.UP_HOST = "http://up.qiniu.com" rputSettings := rio.Settings{ ChunkSize: 4 * 1024 * 1024, Workers: 1, } rio.SetSettings(&rputSettings) var rputThreshold uint64 = 100 * 1024 * 1024 policy := rs.PutPolicy{ Scope: bucket, } var unzipResult UnzipResult unzipResult.Files = make([]UnzipFile, 0) var tErr error //iterate the zip file for _, zipFile := range zipFiles { fileInfo := zipFile.FileHeader.FileInfo() fileName := zipFile.FileHeader.Name fileSize := zipFile.UncompressedSize64 if !utf8.Valid([]byte(fileName)) { fileName, tErr = utils.Gbk2Utf8(fileName) if tErr != nil { err = errors.New(fmt.Sprintf("unsupported file name encoding, %s", tErr.Error())) return } } if fileInfo.IsDir() { continue } zipFileReader, zipErr := zipFile.Open() if zipErr != nil { err = errors.New(fmt.Sprintf("open zip file content failed, %s", zipErr.Error())) return } defer zipFileReader.Close() unzipData, unzipErr := ioutil.ReadAll(zipFileReader) if unzipErr != nil { err = errors.New(fmt.Sprintf("unzip the file content failed, %s", unzipErr.Error())) return } unzipReader := bytes.NewReader(unzipData) //save file to bucket fileName = prefix + fileName if overwrite { policy.Scope = bucket + ":" + fileName } uptoken := policy.Token(this.mac) var unzipFile UnzipFile unzipFile.Key = fileName if fileSize <= rputThreshold { var fputRet fio.PutRet fErr := fio.Put(nil, &fputRet, uptoken, fileName, unzipReader, nil) if fErr != nil { unzipFile.Error = fmt.Sprintf("save unzip file to bucket error, %s", fErr.Error()) } else { unzipFile.Hash = fputRet.Hash } } else { var rputRet rio.PutRet rErr := rio.Put(nil, &rputRet, uptoken, fileName, unzipReader, int64(fileSize), nil) if rErr != nil { unzipFile.Error = fmt.Sprintf("save unzip file to bucket error, %s", rErr.Error()) } else { unzipFile.Hash = rputRet.Hash } } unzipResult.Files = append(unzipResult.Files, unzipFile) } //write result result = unzipResult resultType = ufop.RESULT_TYPE_JSON contentType = ufop.CONTENT_TYPE_JSON return }