vendor/github.com/aliyun/aliyun-oss-go-sdk/sample/comm.go

   1 package sample
   2
   3 import (
   4         "fmt"
   5         "os"
   6         "strings"
   7         "time"
   8
   9         "github.com/aliyun/aliyun-oss-go-sdk/oss"
  10 )
  11
  12 var (
  13         pastDate   = time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
  14         futureDate = time.Date(2049, time.January, 10, 23, 0, 0, 0, time.UTC)
  15 )
  16
  17 // HandleError is the error handling method in the sample code
  18 func HandleError(err error) {
  19         fmt.Println("occurred error:", err)
  20         os.Exit(-1)
  21 }
  22
  23 // GetTestBucket creates the test bucket
  24 func GetTestBucket(bucketName string) (*oss.Bucket, error) {
  25         // New client
  26         client, err := oss.New(endpoint, accessID, accessKey)
  27         if err != nil {
  28                 return nil, err
  29         }
  30
  31         // Create bucket
  32         err = client.CreateBucket(bucketName)
  33         if err != nil {
  34                 return nil, err
  35         }
  36
  37         // Get bucket
  38         bucket, err := client.Bucket(bucketName)
  39         if err != nil {
  40                 return nil, err
  41         }
  42
  43         return bucket, nil
  44 }
  45
  46 // DeleteTestBucketAndLiveChannel 删除sample的channelname和bucket，该函数为了简化sample，让sample代码更明了
  47 func DeleteTestBucketAndLiveChannel(bucketName string) error {
  48         // New Client
  49         client, err := oss.New(endpoint, accessID, accessKey)
  50         if err != nil {
  51                 return err
  52         }
  53
  54         // Get Bucket
  55         bucket, err := client.Bucket(bucketName)
  56         if err != nil {
  57                 return err
  58         }
  59
  60         marker := ""
  61         for {
  62                 result, err := bucket.ListLiveChannel(oss.Marker(marker))
  63                 if err != nil {
  64                         HandleError(err)
  65                 }
  66
  67                 for _, channel := range result.LiveChannel {
  68                         err := bucket.DeleteLiveChannel(channel.Name)
  69                         if err != nil {
  70                                 HandleError(err)
  71                         }
  72                 }
  73
  74                 if result.IsTruncated {
  75                         marker = result.NextMarker
  76                 } else {
  77                         break
  78                 }
  79         }
  80
  81         // Delete Bucket
  82         err = client.DeleteBucket(bucketName)
  83         if err != nil {
  84                 return err
  85         }
  86
  87         return nil
  88 }
  89
  90 // DeleteTestBucketAndObject deletes the test bucket and its objects
  91 func DeleteTestBucketAndObject(bucketName string) error {
  92         // New client
  93         client, err := oss.New(endpoint, accessID, accessKey)
  94         if err != nil {
  95                 return err
  96         }
  97
  98         // Get bucket
  99         bucket, err := client.Bucket(bucketName)
 100         if err != nil {
 101                 return err
 102         }
 103
 104         // Delete part
 105         keyMarker := oss.KeyMarker("")
 106         uploadIDMarker := oss.UploadIDMarker("")
 107         for {
 108                 lmur, err := bucket.ListMultipartUploads(keyMarker, uploadIDMarker)
 109                 if err != nil {
 110                         return err
 111                 }
 112                 for _, upload := range lmur.Uploads {
 113                         var imur = oss.InitiateMultipartUploadResult{Bucket: bucket.BucketName,
 114                                 Key: upload.Key, UploadID: upload.UploadID}
 115                         err = bucket.AbortMultipartUpload(imur)
 116                         if err != nil {
 117                                 return err
 118                         }
 119                 }
 120                 keyMarker = oss.KeyMarker(lmur.NextKeyMarker)
 121                 uploadIDMarker = oss.UploadIDMarker(lmur.NextUploadIDMarker)
 122                 if !lmur.IsTruncated {
 123                         break
 124                 }
 125         }
 126
 127         // Delete objects
 128         marker := oss.Marker("")
 129         for {
 130                 lor, err := bucket.ListObjects(marker)
 131                 if err != nil {
 132                         return err
 133                 }
 134                 for _, object := range lor.Objects {
 135                         err = bucket.DeleteObject(object.Key)
 136                         if err != nil {
 137                                 return err
 138                         }
 139                 }
 140                 marker = oss.Marker(lor.NextMarker)
 141                 if !lor.IsTruncated {
 142                         break
 143                 }
 144         }
 145
 146         // Delete bucket
 147         err = client.DeleteBucket(bucketName)
 148         if err != nil {
 149                 return err
 150         }
 151
 152         return nil
 153 }
 154
 155 // Object defines pair of key and value
 156 type Object struct {
 157         Key   string
 158         Value string
 159 }
 160
 161 // CreateObjects creates some objects
 162 func CreateObjects(bucket *oss.Bucket, objects []Object) error {
 163         for _, object := range objects {
 164                 err := bucket.PutObject(object.Key, strings.NewReader(object.Value))
 165                 if err != nil {
 166                         return err
 167                 }
 168         }
 169         return nil
 170 }
 171
 172 // DeleteObjects deletes some objects.
 173 func DeleteObjects(bucket *oss.Bucket, objects []Object) error {
 174         for _, object := range objects {
 175                 err := bucket.DeleteObject(object.Key)
 176                 if err != nil {
 177                         return err
 178                 }
 179         }
 180         return nil
 181 }