func (c *Client) GetObjectFromRequest(getObjectRequest GetObjectRequest, option *bce.SignOption) (*Object, error) { checkBucketName(getObjectRequest.BucketName) checkObjectKey(getObjectRequest.ObjectKey) req, err := bce.NewRequest("GET", c.GetURL(getObjectRequest.BucketName, getObjectRequest.ObjectKey, nil), nil) if err != nil { return nil, err } option = bce.CheckSignOption(option) getObjectRequest.MergeToSignOption(option) resp, err := c.SendRequest(req, option) if err != nil { return nil, err } object := &Object{ ObjectMetadata: NewObjectMetadataFromHeader(resp.Header), ObjectContent: resp.Body, } return object, nil }
func (c *Client) AppendObject(bucketName, objectKey string, offset int, data interface{}, metadata *ObjectMetadata, option *bce.SignOption) (AppendObjectResponse, error) { checkBucketName(bucketName) checkObjectKey(objectKey) var reader io.Reader if str, ok := data.(string); ok { reader = strings.NewReader(str) } else if byteArray, ok := data.([]byte); ok { reader = bytes.NewReader(byteArray) } else if r, ok := data.(io.Reader); ok { byteArray, err := ioutil.ReadAll(r) if err != nil { return nil, err } reader = bytes.NewReader(byteArray) } else { panic("data type should be string or []byte or io.Reader.") } params := map[string]string{"append": ""} if offset > 0 { params["offset"] = strconv.Itoa(offset) } req, err := bce.NewRequest("POST", c.GetURL(bucketName, objectKey, params), reader) if err != nil { return nil, err } option = bce.CheckSignOption(option) option.AddHeader("Content-Type", util.GuessMimeType(objectKey)) if c.Checksum { option.AddHeader("x-bce-content-sha256", util.GetSha256(data)) } if metadata != nil { metadata.mergeToSignOption(option) } resp, err := c.SendRequest(req, option) if err != nil { return nil, err } appendObjectResponse := NewAppendObjectResponse(resp.Header) return appendObjectResponse, nil }
func (c *Client) UploadPart(uploadPartRequest UploadPartRequest, option *bce.SignOption) (UploadPartResponse, error) { bucketName := uploadPartRequest.BucketName objectKey := uploadPartRequest.ObjectKey checkBucketName(bucketName) checkObjectKey(objectKey) if uploadPartRequest.PartNumber < MIN_PART_NUMBER || uploadPartRequest.PartNumber > MAX_PART_NUMBER { panic(fmt.Sprintf("Invalid partNumber %d. The valid range is from %d to %d.", uploadPartRequest.PartNumber, MIN_PART_NUMBER, MAX_PART_NUMBER)) } if uploadPartRequest.PartSize > 1024*1024*1024*5 { panic(fmt.Sprintf("PartNumber %d: Part Size should not be more than 5GB.", uploadPartRequest.PartSize)) } params := map[string]string{ "partNumber": strconv.Itoa(uploadPartRequest.PartNumber), "uploadId": uploadPartRequest.UploadId, } req, err := bce.NewRequest("PUT", c.GetURL(bucketName, objectKey, params), uploadPartRequest.PartData) if err != nil { return nil, err } option = bce.CheckSignOption(option) option.AddHeaders(map[string]string{ "Content-Length": strconv.FormatInt(uploadPartRequest.PartSize, 10), "Content-Type": "application/octet-stream", }) if _, ok := option.Headers["Content-MD5"]; !ok { option.AddHeader("Content-MD5", util.GetMD5(uploadPartRequest.PartData, true)) } resp, err := c.SendRequest(req, option) if err != nil { return nil, err } uploadPartResponse := NewUploadPartResponse(resp.Header) return uploadPartResponse, nil }
func (c *Client) setBucketAclFromString(bucketName, acl string, option *bce.SignOption) error { params := map[string]string{"acl": ""} req, err := bce.NewRequest("PUT", c.GetURL(bucketName, "", params), nil) if err != nil { return err } option = bce.CheckSignOption(option) headers := map[string]string{"x-bce-acl": acl} option.AddHeaders(headers) _, err = c.SendRequest(req, option) return err }
func (c *Client) InitiateMultipartUpload(initiateMultipartUploadRequest InitiateMultipartUploadRequest, option *bce.SignOption) (*InitiateMultipartUploadResponse, error) { bucketName := initiateMultipartUploadRequest.BucketName objectKey := initiateMultipartUploadRequest.ObjectKey checkBucketName(bucketName) checkObjectKey(objectKey) params := map[string]string{"uploads": ""} req, err := bce.NewRequest("POST", c.GetURL(bucketName, objectKey, params), nil) if err != nil { return nil, err } option = bce.CheckSignOption(option) option.AddHeader("Content-Type", util.GuessMimeType(objectKey)) if initiateMultipartUploadRequest.ObjectMetadata != nil { initiateMultipartUploadRequest.ObjectMetadata.mergeToSignOption(option) } resp, err := c.SendRequest(req, option) if err != nil { return nil, err } bodyContent, err := resp.GetBodyContent() if err != nil { return nil, err } var initiateMultipartUploadResponse *InitiateMultipartUploadResponse err = json.Unmarshal(bodyContent, &initiateMultipartUploadResponse) if err != nil { return nil, err } return initiateMultipartUploadResponse, nil }
func (c *Client) GeneratePresignedUrl(bucketName, objectKey string, option *bce.SignOption) (string, error) { checkBucketName(bucketName) checkObjectKey(objectKey) req, err := bce.NewRequest("GET", c.GetURL(bucketName, objectKey, nil), nil) if err != nil { return "", err } option = bce.CheckSignOption(option) option.HeadersToSign = []string{"host"} authorization := bce.GenerateAuthorization(*c.Credentials, *req, option) url := fmt.Sprintf("%s?authorization=%s", req.URL.String(), util.URLEncode(authorization)) return url, nil }
func (c *Client) PutObject(bucketName, objectKey string, data interface{}, metadata *ObjectMetadata, option *bce.SignOption) (PutObjectResponse, error) { checkObjectKey(objectKey) var reader io.Reader if str, ok := data.(string); ok { reader = strings.NewReader(str) } else if byteArray, ok := data.([]byte); ok { reader = bytes.NewReader(byteArray) } else if r, ok := data.(io.Reader); ok { reader = r } else { panic("data type should be string or []byte or io.Reader.") } req, err := bce.NewRequest("PUT", c.GetURL(bucketName, objectKey, nil), reader) if err != nil { return nil, err } option = bce.CheckSignOption(option) option.AddHeader("Content-Type", util.GuessMimeType(objectKey)) if c.Checksum { option.AddHeader("x-bce-content-sha256", util.GetSha256(data)) } if metadata != nil { metadata.mergeToSignOption(option) } resp, err := c.SendRequest(req, option) if err != nil { return nil, err } putObjectResponse := NewPutObjectResponse(resp.Header) return putObjectResponse, nil }
func (c *Client) GetObjectToFile(getObjectRequest *GetObjectRequest, file *os.File, option *bce.SignOption) (*ObjectMetadata, error) { defer func() { if file != nil { file.Close() } }() checkBucketName(getObjectRequest.BucketName) checkObjectKey(getObjectRequest.ObjectKey) req, err := bce.NewRequest("GET", c.GetURL(getObjectRequest.BucketName, getObjectRequest.ObjectKey, nil), nil) if err != nil { return nil, err } option = bce.CheckSignOption(option) getObjectRequest.MergeToSignOption(option) resp, err := c.SendRequest(req, option) if err != nil { return nil, err } objectMetadata := NewObjectMetadataFromHeader(resp.Header) bodyContent, err := resp.GetBodyContent() if err != nil { return objectMetadata, err } _, err = file.Write(bodyContent) if err != nil { return objectMetadata, err } return objectMetadata, nil }
func (c *Client) CopyObjectFromRequest(copyObjectRequest CopyObjectRequest, option *bce.SignOption) (*CopyObjectResponse, error) { checkBucketName(copyObjectRequest.SrcBucketName) checkBucketName(copyObjectRequest.DestBucketName) checkObjectKey(copyObjectRequest.SrcKey) checkObjectKey(copyObjectRequest.DestKey) req, err := bce.NewRequest("PUT", c.GetURL(copyObjectRequest.DestBucketName, copyObjectRequest.DestKey, nil), nil) if err != nil { return nil, err } option = bce.CheckSignOption(option) source := util.URIEncodeExceptSlash(fmt.Sprintf("/%s/%s", copyObjectRequest.SrcBucketName, copyObjectRequest.SrcKey)) option.AddHeader("x-bce-copy-source", source) copyObjectRequest.mergeToSignOption(option) resp, err := c.SendRequest(req, option) if err != nil { return nil, err } bodyContent, err := resp.GetBodyContent() if err != nil { return nil, err } var copyObjectResponse *CopyObjectResponse err = json.Unmarshal(bodyContent, ©ObjectResponse) if err != nil { return nil, err } return copyObjectResponse, nil }
func (c *Client) OptionsObject(bucketName, objectKey, origin, accessControlRequestMethod, accessControlRequestHeaders string) (*bce.Response, error) { checkBucketName(bucketName) checkObjectKey(objectKey) req, err := bce.NewRequest("OPTIONS", c.GetURL(bucketName, objectKey, nil), nil) if err != nil { return nil, err } option := bce.CheckSignOption(nil) option.AddHeader("Origin", origin) option.AddHeader("Access-Control-Request-Method", accessControlRequestMethod) option.AddHeader("Access-Control-Request-Headers", accessControlRequestHeaders) return c.SendRequest(req, option) }