资源管理

资源管理包括的主要功能有：

  1. mac := qbox.NewMac(accessKey, secretKey)
  2. cfg := storage.Config{
  3.     // 是否使用https域名进行资源管理
  4.     UseHTTPS: false,
  5. }
  7. // 指定空间所在的区域，如果不指定将自动探测
  8. // 如果没有特殊需求，默认不需要指定
  9. //cfg.Zone=&storage.ZoneHuabei
  11. bucketManager := storage.NewBucketManager(mac, &cfg)

获取文件信息

  1. bucket := "if-pbl"
  2. key := "github.png"
  4. fileInfo, sErr := bucketManager.Stat(bucket, key)
  5. if sErr != nil {
  6.     fmt.Println(sErr)
  7.     return
  8. }
  9. fmt.Println(fileInfo.String())
  10. //可以解析文件的PutTime
  11. fmt.Println(storage.ParsePutTime(fileInfo.PutTime))

修改文件MimeType

  1. bucket := "if-pbl"
  2. key := "github.png"
  3. newMime := "image/x-png"
  5. err := bucketManager.ChangeMime(bucket, key, newMime)
  6. if err != nil {
  7.     fmt.Println(err)
  8.     return
  9. }

修改文件存储类型

  1. bucket := "if-pbl"
  2. key := "github.png"
  3. fileType := 1
  5. err := bucketManager.ChangeType(bucket, key, fileType)
  6. if err != nil {
  7.     fmt.Println(err)
  8.     return
  9. }

移动或重命名文件

移动操作本身支持移动文件到相同，不同空间中，在移动的同时也可以支持文件重命名。唯一的限制条件是，移动的源空间和目标空间必须在同一个机房。

源空间目标空间源文件名目标文件名描述
BucketABucketAKeyAKeyB相当于同空间文件重命名
BucketABucketBKeyAKeyA移动文件到BucketB，文件名一致
BucketABucketBKeyAKeyB移动文件到BucketB，文件名变成KeyB

move操作支持强制覆盖选项，即如果目标文件已存在，可以设置强制覆盖选项force来覆盖那个文件的内容。

  1. srcBucket := "if-pbl"
  2. srcKey := "github.png"
  4. //目标空间可以和源空间相同，但是不能为跨机房的空间
  5. destBucket := srcBucket
  6. //目标文件名可以和源文件名相同，也可以不同
  7. destKey := "github-new.png"
  9. //如果目标文件存在，是否强制覆盖，如果不覆盖，默认返回614 file exists
  10. force := false
  11. err := bucketManager.Move(srcBucket, srcKey, destBucket, destKey, force)
  12. if err != nil {
  13.     fmt.Println(err)
  14.     return
  15. }

复制文件副本

文件的复制和文件移动其实操作一样，主要的区别是移动后源文件不存在了，而复制的结果是源文件还存在，只是多了一个新的文件副本。

  1. srcBucket := "if-pbl"
  2. srcKey := "github.png"
  4. //目标空间可以和源空间相同，但是不能为跨机房的空间
  5. destBucket := srcBucket
  6. //目标文件名可以和源文件名相同，也可以不同
  7. destKey := "github-new.png"
  9. //如果目标文件存在，是否强制覆盖，如果不覆盖，默认返回614 file exists
  10. force := false
  11. err := bucketManager.Copy(srcBucket, srcKey, destBucket, destKey, force)
  12. if err != nil {
  13.     fmt.Println(err)
  14.     return
  15. }

删除空间中的文件

  1. bucket := "if-pbl"
  2. key := "github.png"
  4. err := bucketManager.Delete(bucket, key)
  5. if err != nil {
  6.     fmt.Println(err)
  7.     return
  8. }

设置或更新文件的生存时间

可以给已经存在于空间中的文件设置文件生存时间，或者更新已设置了生存时间但尚未被删除的文件的新的生存时间。

  1. bucket := "if-pbl"
  2. key := "github.png"
  3. days := 7
  5. err := bucketManager.DeleteAfterDays(bucket, key, days)
  6. if err != nil {
  7.     fmt.Println(err)
  8.     return
  9. }

获取指定前缀的文件列表

获取指定文件前缀的列表用来从空间列举文件，每次最大的列举数量为1000，如果需要列举超过1000的文件数量，可以根据每次函数调用返回的nextMarker进行循环列举。

  1. bucket := "if-bc"
  2. limit := 1000
  3. prefix := "qshell/"
  4. delimiter := ""
  5. //初始列举marker为空
  6. marker := ""
  8. for {
  9.     entries, _, nextMarker, hashNext, err := bucketManager.ListFiles(bucket, prefix, delimiter, marker, limit)
  10.     if err != nil {
  11.         fmt.Println("list error,", err)
  12.         break
  13.     }
  15.     //print entries
  16.     for _, entry := range entries {
  17.         fmt.Println(entry.Key)
  18.     }
  20.     if hashNext {
  21.         marker = nextMarker
  22.     } else {
  23.         //list end
  24.         break
  25.     }
  27. }

抓取网络资源到空间

  1. bucket := "if-bc"
  2. resURL := "http://devtools.qiniu.com/qiniu.png"
  4. // 指定保存的key
  5. fetchRet, err := bucketManager.Fetch(resURL, bucket, "qiniu.png")
  6. if err != nil {
  7.     fmt.Println("fetch error,", err)
  8. } else {
  9.     fmt.Println(fetchRet.String())
  10. }
  12. // 不指定保存的key，默认用文件hash作为文件名
  13. fetchRet, err = bucketManager.FetchWithoutKey(resURL, bucket)
  14. if err != nil {
  15.     fmt.Println("fetch error,", err)
  16. } else {
  17.     fmt.Println(fetchRet.String())
  18. }

更新镜像空间中存储的文件内容

  1. bucket := "if-bc"
  2. key := "qiniu.png"
  4. err := bucketManager.Prefetch(bucket, key)
  5. if err != nil {
  6.     fmt.Println("fetch error,", err)
  7. }

资源管理批量操作

批量获取文件信息

  1. //每个batch的操作数量不可以超过1000个，如果总数量超过1000，需要分批发送
  2. bucket := "if-pbl"
  3. keys := []string{
  4.     "github1.png",
  5.     "github2.png",
  6.     "github3.png",
  7.     "github4.png",
  8.     "github5.png",
  9. }
  10. statOps := make([]string, 0, len(keys))
  11. for _, key := range keys {
  12.     statOps = append(statOps, storage.URIStat(bucket, key))
  13. }
  15. rets, err := bucketManager.Batch(statOps)
  16. if err != nil {
  17.     // 遇到错误
  18.     if _, ok := err.(*rpc.ErrorInfo); ok {
  19.         for _, ret := range rets {
  20.             // 200 为成功
  21.             fmt.Printf("%d\n", ret.Code)
  22.             if ret.Code != 200 {
  23.                 fmt.Printf("%s\n", ret.Data.Error)
  24.             } else {
  25.                 fmt.Printf("%v\n", ret.Data)
  26.             }
  27.         }
  28.     } else {
  29.         fmt.Printf("batch error, %s", err)
  30.     }
  31. } else {
  32.     // 完全成功
  33.     for _, ret := range rets {
  34.         // 200 为成功
  35.         fmt.Printf("%d\n", ret.Code)
  36.         fmt.Printf("%v\n", ret.Data)
  37.     }
  38. }

批量修改文件类型

  1. //每个batch的操作数量不可以超过1000个，如果总数量超过1000，需要分批发送
  2. bucket := "if-pbl"
  3. chgmKeys := map[string]string{
  4.     "github1.png": "image/x-png",
  5.     "github2.png": "image/x-png",
  6.     "github3.png": "image/x-png",
  7.     "github4.png": "image/x-png",
  8.     "github5.png": "image/x-png",
  9. }
  10. chgmOps := make([]string, 0, len(chgmKeys))
  11. for key, newMime := range chgmKeys {
  12.     chgmOps = append(chgmOps, storage.URIChangeMime(bucket, key, newMime))
  13. }
  15. rets, err := bucketManager.Batch(chgmOps)
  16. if err != nil {
  17.     // 遇到错误
  18.     if _, ok := err.(*rpc.ErrorInfo); ok {
  19.         for _, ret := range rets {
  20.             // 200 为成功
  21.             fmt.Printf("%d\n", ret.Code)
  22.             if ret.Code != 200 {
  23.                 fmt.Printf("%s\n", ret.Data.Error)
  24.             }
  25.         }
  26.     } else {
  27.         fmt.Printf("batch error, %s", err)
  28.     }
  29. } else {
  30.     // 完全成功
  31.     for _, ret := range rets {
  32.         // 200 为成功
  33.         fmt.Printf("%d\n", ret.Code)
  34.         if ret.Code != 200 {
  35.             fmt.Printf("%s\n", ret.Data.Error)
  36.         }
  37.     }
  38. }

批量删除文件

  1. //每个batch的操作数量不可以超过1000个，如果总数量超过1000，需要分批发送
  2. bucket := "if-pbl"
  3. keys := []string{
  4.     "github1.png",
  5.     "github2.png",
  6.     "github3.png",
  7.     "github4.png",
  8.     "github5.png",
  9. }
  10. deleteOps := make([]string, 0, len(keys))
  11. for _, key := range keys {
  12.     deleteOps = append(deleteOps, storage.URIDelete(bucket, key))
  13. }
  15. rets, err := bucketManager.Batch(deleteOps)
  16. if err != nil {
  17.     // 遇到错误
  18.     if _, ok := err.(*rpc.ErrorInfo); ok {
  19.         for _, ret := range rets {
  20.             // 200 为成功
  21.             fmt.Printf("%d\n", ret.Code)
  22.             if ret.Code != 200 {
  23.                 fmt.Printf("%s\n", ret.Data.Error)
  24.             }
  25.         }
  26.     } else {
  27.         fmt.Printf("batch error, %s", err)
  28.     }
  29. } else {
  30.     // 完全成功
  31.     for _, ret := range rets {
  32.         // 200 为成功
  33.         fmt.Printf("%d\n", ret.Code)
  34.     }
  35. }

批量复制文件

  1. srcBucket := "if-pbl"
  2. destBucket := "if-pbl"
  3. force := true
  4. copyKeys := map[string]string{
  5.     "github1.png": "github1-copy.png",
  6.     "github2.png": "github2-copy.png",
  7.     "github3.png": "github3-copy.png",
  8.     "github4.png": "github4-copy.png",
  9.     "github5.png": "github5-copy.png",
  10. }
  11. copyOps := make([]string, 0, len(copyKeys))
  12. for srcKey, destKey := range copyKeys {
  13.     copyOps = append(copyOps, storage.URICopy(srcBucket, srcKey, destBucket, destKey, force))
  14. }
  16. rets, err := bucketManager.Batch(copyOps)
  17. if err != nil {
  18.     // 遇到错误
  19.     if _, ok := err.(*rpc.ErrorInfo); ok {
  20.         for _, ret := range rets {
  21.             // 200 为成功
  22.             fmt.Printf("%d\n", ret.Code)
  23.             if ret.Code != 200 {
  24.                 fmt.Printf("%s\n", ret.Data.Error)
  25.             }
  26.         }
  27.     } else {
  28.         fmt.Printf("batch error, %s", err)
  29.     }
  30. } else {
  31.     // 完全成功
  32.     for _, ret := range rets {
  33.         // 200 为成功
  34.         fmt.Printf("%d\n", ret.Code)
  35.         fmt.Printf("%v\n", ret.Data)
  36.     }
  37. }

批量移动或重命名文件

  1. srcBucket := "if-pbl"
  2. destBucket := "if-pbl"
  3. force := true
  4. moveKeys := map[string]string{
  5.     "github1.png": "github1-move.png",
  6.     "github2.png": "github2-move.png",
  7.     "github3.png": "github3-move.png",
  8.     "github4.png": "github4-move.png",
  9.     "github5.png": "github5-move.png",
  10. }
  11. moveOps := make([]string, 0, len(moveKeys))
  12. for srcKey, destKey := range moveKeys {
  13.     moveOps = append(moveOps, storage.URIMove(srcBucket, srcKey, destBucket, destKey, force))
  14. }
  16. rets, err := bucketManager.Batch(moveOps)
  17. if err != nil {
  18.     // 遇到错误
  19.     if _, ok := err.(*rpc.ErrorInfo); ok {
  20.         for _, ret := range rets {
  21.             // 200 为成功
  22.             fmt.Printf("%d\n", ret.Code)
  23.             if ret.Code != 200 {
  24.                 fmt.Printf("%s\n", ret.Data.Error)
  25.             }
  26.         }
  27.     } else {
  28.         fmt.Printf("batch error, %s", err)
  29.     }
  30. } else {
  31.     // 完全成功
  32.     for _, ret := range rets {
  33.         // 200 为成功
  34.         fmt.Printf("%d\n", ret.Code)
  35.         fmt.Printf("%v\n", ret.Data)
  36.     }
  37. }

批量更新文件的有效期

  1. //每个batch的操作数量不可以超过1000个，如果总数量超过1000，需要分批发送
  2. bucket := "if-bc"
  3. expireKeys := map[string]int{
  4.     "github1.png": 7,
  5.     "github2.png": 8,
  6.     "github3.png": 9,
  7.     "github4.png": 10,
  8.     "github5.png": 11,
  9. }
  10. expireOps := make([]string, 0, len(expireKeys))
  11. for key, expire := range expireKeys {
  12.     expireOps = append(expireOps, storage.URIDeleteAfterDays(bucket, key, expire))
  13. }
  15. rets, err := bucketManager.Batch(expireOps)
  16. if err != nil {
  17.     // 遇到错误
  18.     if _, ok := err.(*rpc.ErrorInfo); ok {
  19.         for _, ret := range rets {
  20.             // 200 为成功
  21.             fmt.Printf("%d\n", ret.Code)
  22.             if ret.Code != 200 {
  23.                 fmt.Printf("%s\n", ret.Data.Error)
  24.             }
  25.         }
  26.     } else {
  27.         fmt.Printf("batch error, %s", err)
  28.     }
  29. } else {
  30.     // 完全成功
  31.     for _, ret := range rets {
  32.         // 200 为成功
  33.         fmt.Printf("%d\n", ret.Code)
  34.         if ret.Code != 200 {
  35.             fmt.Printf("%s\n", ret.Data.Error)
  36.         }
  37.     }
  38. }

批量更新文件存储类型

  1. //每个batch的操作数量不可以超过1000个，如果总数量超过1000，需要分批发送
  2. bucket := "if-pbl"
  3. chtypeKeys := map[string]int{
  4.     "github1.png": 1,
  5.     "github2.png": 1,
  6.     "github3.png": 1,
  7.     "github4.png": 1,
  8.     "github5.png": 1,
  9. }
  10. chtypeOps := make([]string, 0, len(chtypeKeys))
  11. for key, fileType := range chtypeKeys {
  12.     chtypeOps = append(chtypeOps, storage.URIChangeType(bucket, key, fileType))
  13. }
  15. rets, err := bucketManager.Batch(chtypeOps)
  16. if err != nil {
  17.     // 遇到错误
  18.     if _, ok := err.(*rpc.ErrorInfo); ok {
  19.         for _, ret := range rets {
  20.             // 200 为成功
  21.             fmt.Printf("%d\n", ret.Code)
  22.             if ret.Code != 200 {
  23.                 fmt.Printf("%s\n", ret.Data.Error)
  24.             }
  25.         }
  26.     } else {
  27.         fmt.Printf("batch error, %s", err)
  28.     }
  29. } else {
  30.     // 完全成功
  31.     for _, ret := range rets {
  32.         // 200 为成功
  33.         fmt.Printf("%d\n", ret.Code)
  34.         if ret.Code != 200 {
  35.             fmt.Printf("%s\n", ret.Data.Error)
  36.         }
  37.     }
  38. }