func resumableUploadBufDemo(r gio.ReaderAt, fsize int64, key, uptoken string) {
// @gist resumableUploadBuf
var err error
var ret rio.PutRet
var extra = &rio.PutExtra{
// Params: params,
// MimeType: mieType,
// ChunkSize: chunkSize,
// TryTimes: tryTimes,
// Progresses: progresses,
// Notify: notify,
// NotifyErr: NotifyErr,
}
// ret 变量用于存取返回的信息，详情见 resumable.io.PutRet
// uptoken 为业务服务器生成的上传口令
// key 为文件存储的标识
// r 为io.ReaderAt,用于读取数据
// fsize 数据总字节数
// extra 为上传文件的额外信息, 详情见 resumable.io.PutExtra
err = rio.Put(nil, &ret, uptoken, key, r, fsize, extra)
if err != nil {
//上传产生错误
log.Print("resumable.io.Put failed:", err)
return
}
//上传成功，处理返回值
log.Print(ret.Hash)
// @endgist
}
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
}
