8d838d9cb4
build / build (push) Successful in 1m45s
执行时真实时钟与持久授权回读(撤销/过期即停并保留预备份)、写集合写前落盘、 租约与 attempt 身份、恢复队列与原发送身份分离、成功收尾必须释放维护后再登记终态。
232 lines
8.3 KiB
Go
232 lines
8.3 KiB
Go
package v071
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/hmac"
|
|
"crypto/sha1"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// Native OSS version operations deliberately do NOT implement conditionalObjectStore:
|
|
// OSS documents forbid-overwrite as ineffective on versioned buckets. Appending a
|
|
// version is recoverable, but is not an atomic absent-key create. Keep that policy
|
|
// decision separate from this protocol rather than silently weakening the gate.
|
|
type ossVersionStore struct {
|
|
endpoint *url.URL
|
|
bucket, access, secret string
|
|
maxBytes int64
|
|
client *http.Client
|
|
}
|
|
|
|
func newOSSVersionStore(c S3ObjectStoreConfig) (*ossVersionStore, error) {
|
|
u, err := url.Parse(c.Endpoint)
|
|
if err != nil || u.Scheme != "https" || u.Host == "" || u.User != nil || u.Path != "" || u.RawQuery != "" || u.Fragment != "" || c.Provider != "oss" || c.ForcePathStyle || c.Bucket == "" || strings.ContainsAny(c.Bucket, "/.: ") || c.AccessKeyID == "" || c.SecretAccessKey == "" {
|
|
return nil, errors.New("invalid native OSS configuration")
|
|
}
|
|
if c.MaxObjectBytes == 0 {
|
|
c.MaxObjectBytes = 100 * 1024 * 1024
|
|
}
|
|
if c.MaxObjectBytes < 1 {
|
|
return nil, errors.New("invalid OSS size limit")
|
|
}
|
|
client := &http.Client{Timeout: 2 * time.Minute}
|
|
if c.HTTPClient != nil {
|
|
clone := *c.HTTPClient
|
|
client = &clone
|
|
}
|
|
client.CheckRedirect = func(*http.Request, []*http.Request) error { return errors.New("OSS redirect refused") }
|
|
return &ossVersionStore{u, c.Bucket, c.AccessKeyID, c.SecretAccessKey, c.MaxObjectBytes, client}, nil
|
|
}
|
|
|
|
func (s *ossVersionStore) request(ctx context.Context, method, key string, q url.Values, body []byte, headers http.Header) (*http.Response, error) {
|
|
if key != "" && (!validObjectKey(key) || strings.Contains(key, "://") || strings.HasPrefix(key, "/")) {
|
|
return nil, errors.New("invalid OSS key")
|
|
}
|
|
u := *s.endpoint
|
|
u.Host = s.bucket + "." + s.endpoint.Host
|
|
u.Path = "/" + key
|
|
u.RawQuery = q.Encode()
|
|
req, err := http.NewRequestWithContext(ctx, method, u.String(), bytes.NewReader(body))
|
|
if err != nil {
|
|
return nil, errors.New("invalid OSS request")
|
|
}
|
|
req.Header = headers.Clone()
|
|
if req.Header == nil {
|
|
req.Header = make(http.Header)
|
|
}
|
|
req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
|
|
resource := "/" + s.bucket + "/" + key
|
|
keys := make([]string, 0, len(q))
|
|
for k := range q {
|
|
if k == "prefix" || k == "max-keys" || k == "key-marker" || k == "version-id-marker" {
|
|
if method != http.MethodGet || key != "" || !q.Has("versions") || q.Get("prefix") == "" {
|
|
return nil, errors.New("OSS listing must be exact-key scoped and read-only")
|
|
}
|
|
continue // These list filters are not OSS V1 signed subresources.
|
|
}
|
|
if k != "versionId" && k != "versioning" && k != "versions" {
|
|
return nil, errors.New("unsupported OSS subresource")
|
|
}
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
for i, k := range keys {
|
|
if i == 0 {
|
|
resource += "?"
|
|
} else {
|
|
resource += "&"
|
|
}
|
|
resource += k
|
|
if q.Get(k) != "" {
|
|
resource += "=" + q.Get(k)
|
|
}
|
|
}
|
|
oss := map[string]string{}
|
|
for k, v := range req.Header {
|
|
lower := strings.ToLower(k)
|
|
if strings.HasPrefix(lower, "x-oss-") {
|
|
oss[lower] = strings.TrimSpace(strings.Join(v, ","))
|
|
}
|
|
}
|
|
keys = keys[:0]
|
|
for k := range oss {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
canonical := ""
|
|
for _, k := range keys {
|
|
canonical += k + ":" + oss[k] + "\n"
|
|
}
|
|
toSign := method + "\n" + req.Header.Get("Content-MD5") + "\n" + req.Header.Get("Content-Type") + "\n" + req.Header.Get("Date") + "\n" + canonical + resource
|
|
mac := hmac.New(sha1.New, []byte(s.secret))
|
|
_, _ = mac.Write([]byte(toSign))
|
|
req.Header.Set("Authorization", "OSS "+s.access+":"+base64.StdEncoding.EncodeToString(mac.Sum(nil)))
|
|
// No retry middleware and no redirect: an ambiguous write remains one attempt.
|
|
resp, err := s.client.Do(req)
|
|
if err != nil {
|
|
return nil, errors.New("native OSS transport outcome unknown")
|
|
}
|
|
return resp, nil
|
|
}
|
|
func (s *ossVersionStore) versioning(ctx context.Context) error {
|
|
resp, err := s.request(ctx, http.MethodGet, "", url.Values{"versioning": {""}}, nil, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
var value struct {
|
|
Status string `xml:"Status"`
|
|
}
|
|
if resp.StatusCode != 200 || xml.NewDecoder(io.LimitReader(resp.Body, 4096)).Decode(&value) != nil || value.Status != "Enabled" {
|
|
return errors.New("OSS versioning is not confirmed Enabled")
|
|
}
|
|
return nil
|
|
}
|
|
func (s *ossVersionStore) observeVersion(ctx context.Context, key, version string) (objectObservation, error) {
|
|
q := url.Values{}
|
|
if version != "" {
|
|
if version == "null" {
|
|
return objectObservation{}, errors.New("null is not an immutable OSS version")
|
|
}
|
|
q.Set("versionId", version)
|
|
}
|
|
resp, err := s.request(ctx, http.MethodGet, key, q, nil, nil)
|
|
if err != nil {
|
|
return objectObservation{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode == 404 {
|
|
var failure struct {
|
|
Code string `xml:"Code"`
|
|
}
|
|
if xml.NewDecoder(io.LimitReader(resp.Body, 4096)).Decode(&failure) != nil || (failure.Code != "NoSuchKey" && failure.Code != "NoSuchVersion") {
|
|
return objectObservation{}, errors.New("OSS 404 is not an authoritative missing object version")
|
|
}
|
|
return objectObservation{}, nil
|
|
}
|
|
if resp.StatusCode != 200 {
|
|
return objectObservation{}, fmt.Errorf("OSS version read status %d", resp.StatusCode)
|
|
}
|
|
got := resp.Header.Get("x-oss-version-id")
|
|
if got == "" || got == "null" || version != "" && got != version || resp.Header.Get("ETag") == "" || resp.ContentLength < 0 || resp.ContentLength > s.maxBytes {
|
|
return objectObservation{}, errors.New("OSS version identity incomplete")
|
|
}
|
|
hash := sha256.New()
|
|
size, err := io.Copy(hash, io.LimitReader(resp.Body, s.maxBytes+1))
|
|
if err != nil || size != resp.ContentLength {
|
|
return objectObservation{}, errors.New("OSS version body incomplete")
|
|
}
|
|
return objectObservation{Exists: true, VersionID: got, ETag: resp.Header.Get("ETag"), Owner: resp.Header.Get("x-oss-meta-kg-release-owner"), Bytes: size, SHA256: hex.EncodeToString(hash.Sum(nil))}, nil
|
|
}
|
|
|
|
// appendVersion is explicit about its semantics. Callers need an approved version-
|
|
// append plan and a persisted intent; this is not wired as CreateObject.
|
|
func (s *ossVersionStore) appendVersion(ctx context.Context, key string, body []byte, owner string) (objectObservation, error) {
|
|
if len(owner) != 64 || int64(len(body)) > s.maxBytes {
|
|
return objectObservation{}, errObjectWriteRejected
|
|
}
|
|
if _, err := hex.DecodeString(owner); err != nil {
|
|
return objectObservation{}, errObjectWriteRejected
|
|
}
|
|
if err := s.versioning(ctx); err != nil {
|
|
return objectObservation{}, err
|
|
}
|
|
resp, err := s.request(ctx, http.MethodPut, key, nil, body, http.Header{"Content-Type": {"application/octet-stream"}, "X-Oss-Meta-Kg-Release-Owner": {owner}})
|
|
if err != nil {
|
|
return objectObservation{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
version := resp.Header.Get("x-oss-version-id")
|
|
if resp.StatusCode != 200 || version == "" || version == "null" {
|
|
return objectObservation{}, errors.New("OSS append receipt unknown")
|
|
}
|
|
observation, err := s.observeVersion(ctx, key, version)
|
|
sum := sha256.Sum256(body)
|
|
if err != nil {
|
|
return objectObservation{}, err
|
|
}
|
|
if !observation.Exists || observation.Owner != owner || observation.Bytes != int64(len(body)) || observation.SHA256 != hex.EncodeToString(sum[:]) {
|
|
return objectObservation{}, errors.New("OSS exact version readback mismatch")
|
|
}
|
|
return observation, nil
|
|
}
|
|
func (s *ossVersionStore) removeVersion(ctx context.Context, key string, want objectObservation) error {
|
|
if !want.Exists || want.VersionID == "" || want.VersionID == "null" || want.ETag == "" || want.Owner == "" || want.SHA256 == "" {
|
|
return errors.New("OSS deletion requires complete owned version receipt")
|
|
}
|
|
got, err := s.observeVersion(ctx, key, want.VersionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !got.Exists {
|
|
return nil
|
|
}
|
|
if got != want {
|
|
return errors.New("OSS exact version differs from receipt")
|
|
}
|
|
resp, sendErr := s.request(ctx, http.MethodDelete, key, url.Values{"versionId": {want.VersionID}}, nil, nil)
|
|
if resp != nil {
|
|
resp.Body.Close()
|
|
}
|
|
after, readErr := s.observeVersion(ctx, key, want.VersionID)
|
|
if readErr != nil {
|
|
return readErr
|
|
}
|
|
if after.Exists {
|
|
return fmt.Errorf("OSS exact version delete unconfirmed: %v", sendErr)
|
|
}
|
|
return nil
|
|
}
|