k2safe/go-omni
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: complete API-driven projects with infrastructure and business acceptance

Browse Source
This commit is contained in:
k2safe
2026-09-23 17:33:50 +08:00
parent 04a1f7999d
commit 2c74dc0859
137 changed files with 11926 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
storage/oss/oss.go
View File

@@ -19,10 +19,10 @@ type Store struct {
maxBytes int64
}
// New borrows a configured SDK client. This adapter uses simple uploads; large
// multipart uploads are a separate provider capability, not buffered in memory.
// New borrows a configured SDK client. Put uses simple uploads (up to 5 GiB).
// Larger objects use the optional MultipartStore capability.
func New(client *sdk.Client, bucket string, maxBytes int64) (*Store, error) {
if client == nil || bucket == "" || maxBytes < 0 || maxBytes > 5<<30 {
if client == nil || bucket == "" || maxBytes < 0 || maxBytes > 5<<40 {
return nil, errors.New("storage/oss: invalid client, bucket or size limit")
}
if maxBytes == 0 {
@@ -41,7 +41,14 @@ func (s *Store) Put(ctx context.Context, key string, reader io.Reader, size int6
if size > s.maxBytes {
return storage.Info{}, storage.ErrTooLarge
}
_, err := s.client.PutObject(ctx, &sdk.PutObjectRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(key), ContentLength: sdk.Ptr(size), ContentType: sdk.Ptr(contentType), Body: storage.ContextReader{Context: ctx, Reader: reader}})
if size > 5<<30 {
return storage.Info{}, storage.ErrTooLarge
}
checked, err := (storage.UploadPolicy{MaxBytes: s.maxBytes}).PrepareUpload(ctx, reader, size, contentType)
if err != nil {
return storage.Info{}, err
}
_, err = s.client.PutObject(ctx, &sdk.PutObjectRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(key), ContentLength: sdk.Ptr(size), ContentType: sdk.Ptr(contentType), Body: checked})
if err != nil {
return storage.Info{}, mapError(err)
}

133
storage/oss/upload.go Normal file
View File

@@ -0,0 +1,133 @@
package oss
import (
"context"
"errors"
"io"
"net/http"
"strconv"
"time"
"git.yuntuo.hk/k2safe/go-omni/storage"
sdk "github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
)
// PresignPut requires an OSS V4 client configured with
// WithAdditionalHeaders([]string{"content-length"}). Missing signed constraints
// fail closed; the borrowed client is never mutated by this adapter.
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"
}
r, err := s.client.Presign(ctx, &sdk.PutObjectRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(key), ContentLength: sdk.Ptr(size), ContentType: sdk.Ptr(contentType)}, sdk.PresignExpires(ttl))
if err != nil {
return storage.UploadRequest{}, err
}
return uploadRequest(r, size, contentType)
}
func uploadRequest(r *sdk.PresignResult, size int64, contentType string) (storage.UploadRequest, error) {
headers := make(http.Header)
for k, v := range r.SignedHeaders {
headers.Set(k, v)
}
if headers.Get("Content-Length") != strconv.FormatInt(size, 10) || (contentType != "" && headers.Get("Content-Type") != contentType) {
return storage.UploadRequest{}, errors.New("storage/oss: upload requires signed Content-Length and Content-Type; configure V4 and WithAdditionalHeaders(content-length)")
}
return storage.UploadRequest{Method: r.Method, URL: r.URL, Headers: headers, ExpiresAt: r.Expiration}, 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"
}
r, err := s.client.InitiateMultipartUpload(ctx, &sdk.InitiateMultipartUploadRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(key), ContentType: sdk.Ptr(contentType)})
if err != nil {
return storage.MultipartUpload{}, err
}
return storage.MultipartUpload{Key: key, UploadID: sdk.ToString(r.UploadId)}, 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
}
r, err := s.client.UploadPart(ctx, &sdk.UploadPartRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), PartNumber: int32(number), ContentLength: sdk.Ptr(size), Body: reader})
if err != nil {
return storage.Part{}, mapError(err)
}
return storage.Part{Number: number, ETag: sdk.ToString(r.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
}
r, err := s.client.Presign(ctx, &sdk.UploadPartRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), PartNumber: int32(number), ContentLength: sdk.Ptr(size), RequestCommon: sdk.RequestCommon{Headers: map[string]string{"Content-Type": "application/octet-stream"}}}, sdk.PresignExpires(ttl))
if err != nil {
return storage.UploadRequest{}, err
}
return uploadRequest(r, size, "application/octet-stream")
}
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 := s.client.ListParts(ctx, &sdk.ListPartsRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), PartNumberMarker: int32(after), MaxParts: int32(limit)})
if err != nil {
return storage.PartsPage{}, err
}
page := storage.PartsPage{Parts: make([]storage.Part, 0, len(r.Parts))}
for _, p := range r.Parts {
page.Parts = append(page.Parts, storage.Part{Number: int(p.PartNumber), ETag: sdk.ToString(p.ETag), Size: p.Size})
}
if r.IsTruncated {
page.NextMarker = int(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([]sdk.UploadPart, len(parts))
for i, p := range parts {
completed[i] = sdk.UploadPart{PartNumber: int32(p.Number), ETag: sdk.Ptr(p.ETag)}
}
_, err = s.client.CompleteMultipartUpload(ctx, &sdk.CompleteMultipartUploadRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), CompleteMultipartUpload: &sdk.CompleteMultipartUpload{Parts: completed}})
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 := s.client.AbortMultipartUpload(ctx, &sdk.AbortMultipartUploadRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID)})
var serviceError *sdk.ServiceError
if errors.As(err, &serviceError) && serviceError.Code == "NoSuchUpload" {
return nil
}
return err
}
var _ storage.UploadPresigner = (*Store)(nil)
var _ storage.MultipartStore = (*Store)(nil)
var _ storage.PartPresigner = (*Store)(nil)

29
storage/oss/upload_test.go Normal file
View File

@@ -0,0 +1,29 @@
package oss
import (
"context"
"net/http/httptest"
"testing"
"time"
"git.yuntuo.hk/k2safe/go-omni/internal/storagefixture"
"git.yuntuo.hk/k2safe/go-omni/storage/storagetest"
sdk "github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)
func TestUploadProtocol(t *testing.T) {
server := httptest.NewTLSServer(storagefixture.MultipartHandler())
defer server.Close()
cfg := sdk.LoadDefaultConfig().WithRegion("cn-hangzhou").WithEndpoint(server.URL).WithUsePathStyle(true).WithCredentialsProvider(credentials.NewStaticCredentialsProvider("fixtureAccess", "fixtureSecret")).WithHttpClient(server.Client()).WithSignatureVersion(sdk.SignatureVersionV4)
missing, _ := New(sdk.NewClient(cfg), "testbucket", 6<<20)
if _, err := missing.PresignPut(context.Background(), "file", 5, "text/plain", time.Minute); err == nil {
t.Fatal("unsigned length accepted")
}
cfg.WithAdditionalHeaders([]string{"content-length"})
s, err := New(sdk.NewClient(cfg), "testbucket", 6<<20)
if err != nil {
t.Fatal(err)
}
storagetest.RunUploads(t, s, server.Client())
}