go-omni/storage/s3/upload.go

package s3

import (
	"context"
	"errors"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

	"git.yuntuo.hk/k2safe/go-omni/storage"
	"github.com/minio/minio-go/v7"
)

func (s *Store) PresignPut(ctx context.Context, key string, size int64, contentType string, ttl time.Duration) (storage.UploadRequest, error) {
	if err := storage.CheckUpload(ctx, key, size, s.maxBytes, contentType, ttl); err != nil {
		return storage.UploadRequest{}, err
	}
	if size > 5<<30 {
		return storage.UploadRequest{}, storage.ErrTooLarge
	}
	if contentType == "" {
		contentType = "application/octet-stream"
	}
	headers := http.Header{"Content-Length": {strconv.FormatInt(size, 10)}, "Content-Type": {contentType}}
	return s.signUpload(ctx, key, nil, headers, ttl)
}
func (s *Store) signUpload(ctx context.Context, key string, query url.Values, headers http.Header, ttl time.Duration) (storage.UploadRequest, error) {
	expires := time.Now().UTC().Add(ttl)
	u, err := s.client.PresignHeader(ctx, http.MethodPut, s.bucket, key, ttl, query, headers)
	if err != nil {
		return storage.UploadRequest{}, err
	}
	signed := ";" + u.Query().Get("X-Amz-SignedHeaders") + ";"
	for name := range headers {
		if !strings.Contains(signed, ";"+strings.ToLower(name)+";") {
			return storage.UploadRequest{}, errors.New("storage/s3: upload constraints were not signed (SigV4 required)")
		}
	}
	return storage.UploadRequest{Method: http.MethodPut, URL: u.String(), Headers: headers, ExpiresAt: expires}, nil
}
func (s *Store) CreateMultipart(ctx context.Context, key, contentType string) (storage.MultipartUpload, error) {
	if err := storage.Check(ctx, key); err != nil {
		return storage.MultipartUpload{}, err
	}
	if _, err := storage.MediaType(contentType); err != nil {
		return storage.MultipartUpload{}, err
	}
	if contentType == "" {
		contentType = "application/octet-stream"
	}
	id, err := (minio.Core{Client: s.client}).NewMultipartUpload(ctx, s.bucket, key, minio.PutObjectOptions{ContentType: contentType})
	if err != nil {
		return storage.MultipartUpload{}, err
	}
	return storage.MultipartUpload{Key: key, UploadID: id}, nil
}
func (s *Store) UploadPart(ctx context.Context, upload storage.MultipartUpload, number int, body io.Reader, size int64) (storage.Part, error) {
	if err := storage.CheckPart(ctx, upload, number, size, s.maxBytes); err != nil {
		return storage.Part{}, err
	}
	reader, err := (storage.UploadPolicy{MaxBytes: s.maxBytes}).PrepareUpload(ctx, body, size, "")
	if err != nil {
		return storage.Part{}, err
	}
	part, err := (minio.Core{Client: s.client}).PutObjectPart(ctx, s.bucket, upload.Key, upload.UploadID, number, reader, size, minio.PutObjectPartOptions{})
	if err != nil {
		return storage.Part{}, err
	}
	return storage.Part{Number: number, ETag: part.ETag, Size: size}, nil
}
func (s *Store) PresignPart(ctx context.Context, upload storage.MultipartUpload, number int, size int64, ttl time.Duration) (storage.UploadRequest, error) {
	if err := storage.CheckPart(ctx, upload, number, size, s.maxBytes); err != nil {
		return storage.UploadRequest{}, err
	}
	if err := storage.CheckUpload(ctx, upload.Key, size, s.maxBytes, "", ttl); err != nil {
		return storage.UploadRequest{}, err
	}
	return s.signUpload(ctx, upload.Key, url.Values{"uploadId": {upload.UploadID}, "partNumber": {strconv.Itoa(number)}}, http.Header{"Content-Length": {strconv.FormatInt(size, 10)}, "Content-Type": {"application/octet-stream"}}, ttl)
}
func (s *Store) ListParts(ctx context.Context, upload storage.MultipartUpload, after, limit int) (storage.PartsPage, error) {
	if err := storage.CheckPartsPage(ctx, upload, after, limit); err != nil {
		return storage.PartsPage{}, err
	}
	r, err := (minio.Core{Client: s.client}).ListObjectParts(ctx, s.bucket, upload.Key, upload.UploadID, after, limit)
	if err != nil {
		return storage.PartsPage{}, err
	}
	page := storage.PartsPage{Parts: make([]storage.Part, 0, len(r.ObjectParts))}
	for _, p := range r.ObjectParts {
		page.Parts = append(page.Parts, storage.Part{Number: p.PartNumber, ETag: p.ETag, Size: p.Size})
	}
	if r.IsTruncated {
		page.NextMarker = r.NextPartNumberMarker
	}
	return page, nil
}
func (s *Store) CompleteMultipart(ctx context.Context, upload storage.MultipartUpload, parts []storage.Part) (storage.Info, error) {
	size, err := storage.VerifyParts(ctx, s, upload, parts, s.maxBytes)
	if err != nil {
		return storage.Info{}, err
	}
	completed := make([]minio.CompletePart, len(parts))
	for i, p := range parts {
		completed[i] = minio.CompletePart{PartNumber: p.Number, ETag: strings.Trim(p.ETag, "\"")}
	}
	_, err = (minio.Core{Client: s.client}).CompleteMultipartUpload(ctx, s.bucket, upload.Key, upload.UploadID, completed, minio.PutObjectOptions{})
	if err != nil {
		return storage.Info{}, err
	}
	return storage.Info{Key: upload.Key, Size: size, ModifiedAt: time.Now().UTC()}, nil
}
func (s *Store) AbortMultipart(ctx context.Context, upload storage.MultipartUpload) error {
	if err := storage.CheckMultipart(ctx, upload); err != nil {
		return err
	}
	err := (minio.Core{Client: s.client}).AbortMultipartUpload(ctx, s.bucket, upload.Key, upload.UploadID)
	if minio.ToErrorResponse(err).Code == "NoSuchUpload" {
		return nil
	}
	return err
}

var _ storage.UploadPresigner = (*Store)(nil)
var _ storage.MultipartStore = (*Store)(nil)
var _ storage.PartPresigner = (*Store)(nil)