vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/select_object.go

   1 package oss
   2
   3 import (
   4         "bytes"
   5         "encoding/xml"
   6         "hash/crc32"
   7         "io"
   8         "io/ioutil"
   9         "net/http"
  10         "os"
  11         "strings"
  12 )
  13
  14 // CreateSelectCsvObjectMeta is Creating csv object meta
  15 //
  16 // key                  the object key.
  17 // csvMeta                      the csv file meta
  18 // options              the options for create csv Meta  of the object.
  19 //
  20 // MetaEndFrameCSV      the csv file meta info
  21 // error                it's nil if no error, otherwise it's an error object.
  22 //
  23 func (bucket Bucket) CreateSelectCsvObjectMeta(key string, csvMeta CsvMetaRequest, options ...Option) (MetaEndFrameCSV, error) {
  24         var endFrame MetaEndFrameCSV
  25         params := map[string]interface{}{}
  26         params["x-oss-process"] = "csv/meta"
  27
  28         csvMeta.encodeBase64()
  29         bs, err := xml.Marshal(csvMeta)
  30         if err != nil {
  31                 return endFrame, err
  32         }
  33         buffer := new(bytes.Buffer)
  34         buffer.Write(bs)
  35
  36         resp, err := bucket.DoPostSelectObject(key, params, buffer, options...)
  37         if err != nil {
  38                 return endFrame, err
  39         }
  40         defer resp.Body.Close()
  41
  42         _, err = ioutil.ReadAll(resp)
  43
  44         return resp.Frame.MetaEndFrameCSV, err
  45 }
  46
  47 // CreateSelectJsonObjectMeta is Creating json object meta
  48 //
  49 // key                          the object key.
  50 // csvMeta                              the json file meta
  51 // options                      the options for create json Meta  of the object.
  52 //
  53 // MetaEndFrameJSON     the json file meta info
  54 // error                        it's nil if no error, otherwise it's an error object.
  55 //
  56 func (bucket Bucket) CreateSelectJsonObjectMeta(key string, jsonMeta JsonMetaRequest, options ...Option) (MetaEndFrameJSON, error) {
  57         var endFrame MetaEndFrameJSON
  58         params := map[string]interface{}{}
  59         params["x-oss-process"] = "json/meta"
  60
  61         bs, err := xml.Marshal(jsonMeta)
  62         if err != nil {
  63                 return endFrame, err
  64         }
  65         buffer := new(bytes.Buffer)
  66         buffer.Write(bs)
  67
  68         resp, err := bucket.DoPostSelectObject(key, params, buffer, options...)
  69         if err != nil {
  70                 return endFrame, err
  71         }
  72         defer resp.Body.Close()
  73
  74         _, err = ioutil.ReadAll(resp)
  75
  76         return resp.Frame.MetaEndFrameJSON, err
  77 }
  78
  79 // SelectObject is the select object api, approve csv and json file.
  80 //
  81 // key                  the object key.
  82 // selectReq            the request data for select object
  83 // options              the options for select file of the object.
  84 //
  85 // o.ReadCloser         reader instance for reading data from response. It must be called close() after the usage and only valid when error is nil.
  86 // error                it's nil if no error, otherwise it's an error object.
  87 //
  88 func (bucket Bucket) SelectObject(key string, selectReq SelectRequest, options ...Option) (io.ReadCloser, error) {
  89         params := map[string]interface{}{}
  90         if selectReq.InputSerializationSelect.JsonBodyInput.JsonIsEmpty() {
  91                 params["x-oss-process"] = "csv/select" // default select csv file
  92         } else {
  93                 params["x-oss-process"] = "json/select"
  94         }
  95         selectReq.encodeBase64()
  96         bs, err := xml.Marshal(selectReq)
  97         if err != nil {
  98                 return nil, err
  99         }
 100         buffer := new(bytes.Buffer)
 101         buffer.Write(bs)
 102         resp, err := bucket.DoPostSelectObject(key, params, buffer, options...)
 103         if err != nil {
 104                 return nil, err
 105         }
 106         if selectReq.OutputSerializationSelect.EnablePayloadCrc != nil && *selectReq.OutputSerializationSelect.EnablePayloadCrc == true {
 107                 resp.Frame.EnablePayloadCrc = true
 108         }
 109         resp.Frame.OutputRawData = strings.ToUpper(resp.Headers.Get("x-oss-select-output-raw")) == "TRUE"
 110
 111         return resp, err
 112 }
 113
 114 // DoPostSelectObject is the SelectObject/CreateMeta api, approve csv and json file.
 115 //
 116 // key                          the object key.
 117 // params                               the resource of oss approve csv/meta, json/meta, csv/select, json/select.
 118 // buf                                  the request data trans to buffer.
 119 // options                      the options for select file of the object.
 120 //
 121 // SelectObjectResponse         the response of select object.
 122 // error                        it's nil if no error, otherwise it's an error object.
 123 //
 124 func (bucket Bucket) DoPostSelectObject(key string, params map[string]interface{}, buf *bytes.Buffer, options ...Option) (*SelectObjectResponse, error) {
 125         resp, err := bucket.do("POST", key, params, options, buf, nil)
 126         if err != nil {
 127                 return nil, err
 128         }
 129
 130         result := &SelectObjectResponse{
 131                 Body:       resp.Body,
 132                 StatusCode: resp.StatusCode,
 133                 Frame:      SelectObjectResult{},
 134         }
 135         result.Headers = resp.Headers
 136         // result.Frame = SelectObjectResult{}
 137         result.ReadTimeOut = bucket.GetConfig().Timeout
 138
 139         // Progress
 140         listener := GetProgressListener(options)
 141
 142         // CRC32
 143         crcCalc := crc32.NewIEEE()
 144         result.WriterForCheckCrc32 = crcCalc
 145         result.Body = TeeReader(resp.Body, nil, 0, listener, nil)
 146
 147         err = CheckRespCode(resp.StatusCode, []int{http.StatusPartialContent, http.StatusOK})
 148
 149         return result, err
 150 }
 151
 152 // SelectObjectIntoFile is the selectObject to file api
 153 //
 154 // key          the object key.
 155 // fileName             saving file's name to localstation.
 156 // selectReq            the request data for select object
 157 // options              the options for select file of the object.
 158 //
 159 // error        it's nil if no error, otherwise it's an error object.
 160 //
 161 func (bucket Bucket) SelectObjectIntoFile(key, fileName string, selectReq SelectRequest, options ...Option) error {
 162         tempFilePath := fileName + TempFileSuffix
 163
 164         params := map[string]interface{}{}
 165         if selectReq.InputSerializationSelect.JsonBodyInput.JsonIsEmpty() {
 166                 params["x-oss-process"] = "csv/select" // default select csv file
 167         } else {
 168                 params["x-oss-process"] = "json/select"
 169         }
 170         selectReq.encodeBase64()
 171         bs, err := xml.Marshal(selectReq)
 172         if err != nil {
 173                 return err
 174         }
 175         buffer := new(bytes.Buffer)
 176         buffer.Write(bs)
 177         resp, err := bucket.DoPostSelectObject(key, params, buffer, options...)
 178         if err != nil {
 179                 return err
 180         }
 181         defer resp.Close()
 182
 183         // If the local file does not exist, create a new one. If it exists, overwrite it.
 184         fd, err := os.OpenFile(tempFilePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, FilePermMode)
 185         if err != nil {
 186                 return err
 187         }
 188
 189         // Copy the data to the local file path.
 190         _, err = io.Copy(fd, resp)
 191         fd.Close()
 192         if err != nil {
 193                 return err
 194         }
 195
 196         return os.Rename(tempFilePath, fileName)
 197 }