diff --git a/api/data/info.go b/api/data/info.go index c8f9351..09130b5 100644 --- a/api/data/info.go +++ b/api/data/info.go @@ -57,8 +57,9 @@ type ( // BucketSettings stores settings such as versioning. BucketSettings struct { - Versioning string `json:"versioning"` - LockConfiguration *ObjectLockConfiguration `json:"lock_configuration"` + Versioning string `json:"versioning"` + LockConfiguration *ObjectLockConfiguration `json:"lock_configuration"` + LifecycleConfiguration *LifecycleConfiguration `json:"lifecycle_configuration"` } // CORSConfiguration stores CORS configuration of a request. diff --git a/api/data/lifecycle.go b/api/data/lifecycle.go new file mode 100644 index 0000000..4f9b710 --- /dev/null +++ b/api/data/lifecycle.go @@ -0,0 +1,69 @@ +package data + +import "encoding/xml" + +type ( + LifecycleConfiguration struct { + XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ LifecycleConfiguration" json:"-"` + Rules []Rule `xml:"Rule" json:"Rule"` + } + + Rule struct { + AbortIncompleteMultipartUpload AbortIncompleteMultipartUpload `xml:"AbortIncompleteMultipartUpload" json:"AbortIncompleteMultipartUpload"` + Expiration Expiration `xml:"Expiration" json:"Expiration"` + Filter LifecycleRuleFilter `xml:"Filter" json:"Filter"` + ID string `xml:"ID" json:"ID"` + NoncurrentVersionExpiration NoncurrentVersionExpiration `xml:"NoncurrentVersionExpiration" json:"NoncurrentVersionExpiration"` + NoncurrentVersionTransitions []NoncurrentVersionTransition `xml:"NoncurrentVersionTransition" json:"NoncurrentVersionTransition"` + Prefix string `xml:"Prefix" json:"Prefix"` + Status string `xml:"Status" json:"Status"` + Transitions []Transition `xml:"Transition" json:"Transition"` + } + + AbortIncompleteMultipartUpload struct { + DaysAfterInitiation int64 `xml:"DaysAfterInitiation"` + } + + Expiration struct { + Date string `xml:"Date" json:"Date"` + Days int64 `xml:"Days" json:"Days"` + ExpiredObjectDeleteMarker bool `xml:"ExpiredObjectDeleteMarker" json:"ExpiredObjectDeleteMarker"` + } + + LifecycleRuleFilter struct { + And LifecycleRuleAndOperator `xml:"And" json:"And"` + ObjectSizeGreaterThan int64 `xml:"ObjectSizeGreaterThan" json:"ObjectSizeGreaterThan"` + ObjectSizeLessThan int64 `xml:"ObjectSizeLessThan" json:"ObjectSizeLessThan"` + Prefix string `xml:"Prefix" json:"Prefix"` + Tag Tag `xml:"Tag" json:"Tag"` + } + + LifecycleRuleAndOperator struct { + ObjectSizeGreaterThan int64 `xml:"ObjectSizeGreaterThan" json:"ObjectSizeGreaterThan"` + ObjectSizeLessThan int64 `xml:"ObjectSizeLessThan" json:"ObjectSizeLessThan"` + Prefix string `xml:"Prefix" json:"Prefix"` + Tags []Tag `xml:"Tags" json:"Tags"` + } + + Tag struct { + Key string `xml:"Key" json:"Key"` + Value string `xml:"Value" json:"Value"` + } + + NoncurrentVersionExpiration struct { + NewerNoncurrentVersions int64 `xml:"NewerNoncurrentVersions" json:"NewerNoncurrentVersions"` + NoncurrentDays int64 `xml:"NoncurrentDays" json:"NoncurrentDays"` + } + + NoncurrentVersionTransition struct { + NewerNoncurrentVersions int64 `xml:"NewerNoncurrentVersions" json:"NewerNoncurrentVersions"` + NoncurrentDays int64 `xml:"NoncurrentDays" json:"NoncurrentDays"` + StorageClass string `xml:"StorageClass" json:"StorageClass"` + } + + Transition struct { + Date string `xml:"Date" json:"Date"` + Days int64 `xml:"Days" json:"Days"` + StorageClass string `xml:"StorageClass" json:"StorageClass"` + } +) diff --git a/api/handler/lifecycle.go b/api/handler/lifecycle.go new file mode 100644 index 0000000..781d256 --- /dev/null +++ b/api/handler/lifecycle.go @@ -0,0 +1,129 @@ +package handler + +import ( + "context" + "encoding/xml" + "fmt" + "net/http" + + "github.com/nspcc-dev/neofs-s3-gw/api" + "github.com/nspcc-dev/neofs-s3-gw/api/data" + apiErrors "github.com/nspcc-dev/neofs-s3-gw/api/errors" + "github.com/nspcc-dev/neofs-s3-gw/api/layer" +) + +func (h *handler) PutBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) { + reqInfo := api.GetReqInfo(r.Context()) + + bktInfo, err := h.obj.GetBucketInfo(r.Context(), reqInfo.BucketName) + if err != nil { + h.logAndSendError(w, "could not get bucket info", reqInfo, err) + return + } + if err = checkOwner(bktInfo, r.Header.Get(api.AmzExpectedBucketOwner)); err != nil { + h.logAndSendError(w, "expected owner doesn't match", reqInfo, err) + return + } + + lifecycleConf := &data.LifecycleConfiguration{} + if err = xml.NewDecoder(r.Body).Decode(lifecycleConf); err != nil { + h.logAndSendError(w, "couldn't parse lifecycle configuration", reqInfo, err) + return + } + + if err = checkLifecycleConfiguration(lifecycleConf); err != nil { + h.logAndSendError(w, "invalid lifecycle configuration", reqInfo, err) + return + } + + if err = h.updateLifecycleConfiguration(r.Context(), bktInfo, lifecycleConf); err != nil { + h.logAndSendError(w, "couldn't put bucket settings", reqInfo, err) + return + } +} + +func (h *handler) GetBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) { + reqInfo := api.GetReqInfo(r.Context()) + + bktInfo, err := h.obj.GetBucketInfo(r.Context(), reqInfo.BucketName) + if err != nil { + h.logAndSendError(w, "could not get bucket info", reqInfo, err) + return + } + if err = checkOwner(bktInfo, r.Header.Get(api.AmzExpectedBucketOwner)); err != nil { + h.logAndSendError(w, "expected owner doesn't match", reqInfo, err) + return + } + + settings, err := h.obj.GetBucketSettings(r.Context(), bktInfo) + if err != nil { + h.logAndSendError(w, "couldn't get bucket settings", reqInfo, err) + return + } + + if settings.LifecycleConfiguration == nil { + h.logAndSendError(w, "lifecycle configuration doesn't exist", reqInfo, + apiErrors.GetAPIError(apiErrors.ErrNoSuchLifecycleConfiguration)) + return + } + + if err = api.EncodeToResponse(w, settings.LifecycleConfiguration); err != nil { + h.logAndSendError(w, "something went wrong", reqInfo, err) + } +} + +func (h *handler) DeleteBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) { + reqInfo := api.GetReqInfo(r.Context()) + + bktInfo, err := h.obj.GetBucketInfo(r.Context(), reqInfo.BucketName) + if err != nil { + h.logAndSendError(w, "could not get bucket info", reqInfo, err) + return + } + if err = checkOwner(bktInfo, r.Header.Get(api.AmzExpectedBucketOwner)); err != nil { + h.logAndSendError(w, "expected owner doesn't match", reqInfo, err) + return + } + + if err = h.updateLifecycleConfiguration(r.Context(), bktInfo, nil); err != nil { + h.logAndSendError(w, "couldn't put bucket settings", reqInfo, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func (h *handler) updateLifecycleConfiguration(ctx context.Context, bktInfo *data.BucketInfo, lifecycleConf *data.LifecycleConfiguration) error { + settings, err := h.obj.GetBucketSettings(ctx, bktInfo) + if err != nil { + return fmt.Errorf("couldn't get bucket settings: %w", err) + } + + settings.LifecycleConfiguration = lifecycleConf + sp := &layer.PutSettingsParams{ + BktInfo: bktInfo, + Settings: settings, + } + + if err = h.obj.PutBucketSettings(ctx, sp); err != nil { + return fmt.Errorf("couldn't put bucket settings: %w", err) + } + + return nil +} + +func checkLifecycleConfiguration(conf *data.LifecycleConfiguration) error { + if len(conf.Rules) == 0 { + return apiErrors.GetAPIError(apiErrors.ErrMalformedXML) + } + if len(conf.Rules) > 1000 { + return fmt.Errorf("you cannot have more than 1000 rules") + } + + for _, rule := range conf.Rules { + if rule.Status != enabledValue && rule.Status != disabledValue { + return apiErrors.GetAPIError(apiErrors.ErrMalformedXML) + } + } + + return nil +} diff --git a/api/handler/locking.go b/api/handler/locking.go index 1130e4f..e7f1a67 100644 --- a/api/handler/locking.go +++ b/api/handler/locking.go @@ -19,6 +19,7 @@ const ( yearDuration = 365 * dayDuration enabledValue = "Enabled" + disabledValue = "Disabled" governanceMode = "GOVERNANCE" complianceMode = "COMPLIANCE" legalHoldOn = "ON" diff --git a/api/handler/not_support.go b/api/handler/not_support.go index 2d4d3e2..c4e1bdb 100644 --- a/api/handler/not_support.go +++ b/api/handler/not_support.go @@ -11,10 +11,6 @@ func (h *handler) DeleteBucketPolicyHandler(w http.ResponseWriter, r *http.Reque h.logAndSendError(w, "not supported", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotSupported)) } -func (h *handler) DeleteBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) { - h.logAndSendError(w, "not supported", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotSupported)) -} - func (h *handler) DeleteBucketEncryptionHandler(w http.ResponseWriter, r *http.Request) { h.logAndSendError(w, "not supported", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotSupported)) } diff --git a/api/handler/unimplemented.go b/api/handler/unimplemented.go index 05f2970..0e71052 100644 --- a/api/handler/unimplemented.go +++ b/api/handler/unimplemented.go @@ -11,10 +11,6 @@ func (h *handler) SelectObjectContentHandler(w http.ResponseWriter, r *http.Requ h.logAndSendError(w, "not implemented", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotImplemented)) } -func (h *handler) GetBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) { - h.logAndSendError(w, "not implemented", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotImplemented)) -} - func (h *handler) GetBucketEncryptionHandler(w http.ResponseWriter, r *http.Request) { h.logAndSendError(w, "not implemented", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotImplemented)) } @@ -51,10 +47,6 @@ func (h *handler) ListObjectsV2MHandler(w http.ResponseWriter, r *http.Request) h.logAndSendError(w, "not implemented", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotImplemented)) } -func (h *handler) PutBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) { - h.logAndSendError(w, "not implemented", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotImplemented)) -} - func (h *handler) PutBucketEncryptionHandler(w http.ResponseWriter, r *http.Request) { h.logAndSendError(w, "not implemented", api.GetReqInfo(r.Context()), errors.GetAPIError(errors.ErrNotImplemented)) }