frostfs-s3-gw/api/handler/lifecycle.go

package handler

import (
	"context"
	"encoding/base64"
	"fmt"
	"net/http"
	"time"

	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/data"
	apierr "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/errors"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/layer"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/middleware"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/internal/frostfs/util"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
)

const (
	maxRules                   = 1000
	maxRuleIDLen               = 255
	maxNewerNoncurrentVersions = 100
)

func (h *handler) GetBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	reqInfo := middleware.GetReqInfo(ctx)

	bktInfo, err := h.getBucketAndCheckOwner(r, reqInfo.BucketName)
	if err != nil {
		h.logAndSendError(w, "could not get bucket info", reqInfo, err)
		return
	}

	cfg, err := h.obj.GetBucketLifecycleConfiguration(ctx, bktInfo)
	if err != nil {
		h.logAndSendError(w, "could not get bucket lifecycle configuration", reqInfo, err)
		return
	}

	if err = middleware.EncodeToResponse(w, cfg); err != nil {
		h.logAndSendError(w, "could not encode GetBucketLifecycle response", reqInfo, err)
		return
	}
}

func (h *handler) PutBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	reqInfo := middleware.GetReqInfo(ctx)

	// Content-Md5 is required and should be set
	// https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html
	if _, ok := r.Header[api.ContentMD5]; !ok {
		h.logAndSendError(w, "missing Content-MD5", reqInfo, apierr.GetAPIError(apierr.ErrMissingContentMD5))
		return
	}

	if _, err := base64.StdEncoding.DecodeString(r.Header.Get(api.ContentMD5)); err != nil {
		h.logAndSendError(w, "invalid Content-MD5", reqInfo, apierr.GetAPIError(apierr.ErrInvalidDigest))
		return
	}

	bktInfo, err := h.getBucketAndCheckOwner(r, reqInfo.BucketName)
	if err != nil {
		h.logAndSendError(w, "could not get bucket info", reqInfo, err)
		return
	}

	cfg := new(data.LifecycleConfiguration)
	if err = h.cfg.NewXMLDecoder(r.Body).Decode(cfg); err != nil {
		h.logAndSendError(w, "could not decode body", reqInfo, fmt.Errorf("%w: %s", apierr.GetAPIError(apierr.ErrMalformedXML), err.Error()))
		return
	}

	networkInfo, err := h.obj.GetNetworkInfo(ctx)
	if err != nil {
		h.logAndSendError(w, "could not get network info", reqInfo, err)
		return
	}

	if err = checkLifecycleConfiguration(ctx, cfg, &networkInfo); err != nil {
		h.logAndSendError(w, "invalid lifecycle configuration", reqInfo, fmt.Errorf("%w: %s", apierr.GetAPIError(apierr.ErrMalformedXML), err.Error()))
		return
	}

	params := &layer.PutBucketLifecycleParams{
		BktInfo:      bktInfo,
		LifecycleCfg: cfg,
	}

	params.CopiesNumbers, err = h.pickCopiesNumbers(parseMetadata(r), reqInfo.Namespace, bktInfo.LocationConstraint)
	if err != nil {
		h.logAndSendError(w, "invalid copies number", reqInfo, err)
		return
	}

	if err = h.obj.PutBucketLifecycleConfiguration(ctx, params); err != nil {
		h.logAndSendError(w, "could not put bucket lifecycle configuration", reqInfo, err)
		return
	}
}

func (h *handler) DeleteBucketLifecycleHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	reqInfo := middleware.GetReqInfo(ctx)

	bktInfo, err := h.getBucketAndCheckOwner(r, reqInfo.BucketName)
	if err != nil {
		h.logAndSendError(w, "could not get bucket info", reqInfo, err)
		return
	}

	if err = h.obj.DeleteBucketLifecycleConfiguration(ctx, bktInfo); err != nil {
		h.logAndSendError(w, "could not delete bucket lifecycle configuration", reqInfo, err)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

func checkLifecycleConfiguration(ctx context.Context, cfg *data.LifecycleConfiguration, ni *netmap.NetworkInfo) error {
	now := layer.TimeNow(ctx)

	if len(cfg.Rules) > maxRules {
		return fmt.Errorf("number of rules cannot be greater than %d", maxRules)
	}

	ids := make(map[string]struct{}, len(cfg.Rules))
	for i, rule := range cfg.Rules {
		if _, ok := ids[rule.ID]; ok && rule.ID != "" {
			return fmt.Errorf("duplicate 'ID': %s", rule.ID)
		}
		ids[rule.ID] = struct{}{}

		if len(rule.ID) > maxRuleIDLen {
			return fmt.Errorf("'ID' value cannot be longer than %d characters", maxRuleIDLen)
		}

		if rule.Status != data.LifecycleStatusEnabled && rule.Status != data.LifecycleStatusDisabled {
			return fmt.Errorf("invalid lifecycle status: %s", rule.Status)
		}

		if rule.AbortIncompleteMultipartUpload == nil && rule.Expiration == nil && rule.NonCurrentVersionExpiration == nil {
			return fmt.Errorf("at least one action needs to be specified in a rule")
		}

		if rule.AbortIncompleteMultipartUpload != nil {
			if rule.AbortIncompleteMultipartUpload.DaysAfterInitiation != nil &&
				*rule.AbortIncompleteMultipartUpload.DaysAfterInitiation <= 0 {
				return fmt.Errorf("days after initiation must be a positive integer: %d", *rule.AbortIncompleteMultipartUpload.DaysAfterInitiation)
			}

			if rule.Filter != nil && (rule.Filter.Tag != nil || (rule.Filter.And != nil && len(rule.Filter.And.Tags) > 0)) {
				return fmt.Errorf("abort incomplete multipart upload cannot be specified with tags")
			}
		}

		if rule.Expiration != nil {
			if rule.Expiration.ExpiredObjectDeleteMarker != nil {
				if rule.Expiration.Days != nil || rule.Expiration.Date != "" {
					return fmt.Errorf("expired object delete marker cannot be specified with days or date")
				}

				if rule.Filter != nil && (rule.Filter.Tag != nil || (rule.Filter.And != nil && len(rule.Filter.And.Tags) > 0)) {
					return fmt.Errorf("expired object delete marker cannot be specified with tags")
				}
			}

			if rule.Expiration.Days != nil && *rule.Expiration.Days <= 0 {
				return fmt.Errorf("expiration days must be a positive integer: %d", *rule.Expiration.Days)
			}

			if rule.Expiration.Date != "" {
				parsedTime, err := time.Parse("2006-01-02T15:04:05Z", rule.Expiration.Date)
				if err != nil {
					return fmt.Errorf("invalid value of expiration date: %s", rule.Expiration.Date)
				}

				epoch, err := util.TimeToEpoch(ni, now, parsedTime)
				if err != nil {
					return fmt.Errorf("convert time to epoch: %w", err)
				}

				cfg.Rules[i].Expiration.Epoch = &epoch
			}
		}

		if rule.NonCurrentVersionExpiration != nil {
			if rule.NonCurrentVersionExpiration.NewerNonCurrentVersions != nil &&
				(*rule.NonCurrentVersionExpiration.NewerNonCurrentVersions > maxNewerNoncurrentVersions ||
					*rule.NonCurrentVersionExpiration.NewerNonCurrentVersions <= 0) {
				return fmt.Errorf("invalid value of newer noncurrent versions: %d", *rule.NonCurrentVersionExpiration.NewerNonCurrentVersions)
			}

			if rule.NonCurrentVersionExpiration.NonCurrentDays != nil && *rule.NonCurrentVersionExpiration.NonCurrentDays <= 0 {
				return fmt.Errorf("invalid value of noncurrent days: %d", *rule.NonCurrentVersionExpiration.NonCurrentDays)
			}
		}

		if err := checkLifecycleRuleFilter(rule.Filter); err != nil {
			return err
		}
	}

	return nil
}

func checkLifecycleRuleFilter(filter *data.LifecycleRuleFilter) error {
	if filter == nil {
		return nil
	}

	var fields int

	if filter.And != nil {
		fields++
		for _, tag := range filter.And.Tags {
			err := checkTag(tag)
			if err != nil {
				return err
			}
		}

		if filter.And.ObjectSizeGreaterThan != nil && filter.And.ObjectSizeLessThan != nil &&
			*filter.And.ObjectSizeLessThan <= *filter.And.ObjectSizeGreaterThan {
			return fmt.Errorf("the maximum object size must be larger than the minimum object size")
		}
	}

	if filter.ObjectSizeGreaterThan != nil {
		fields++
	}

	if filter.ObjectSizeLessThan != nil {
		fields++
	}

	if filter.Prefix != "" {
		fields++
	}

	if filter.Tag != nil {
		fields++
		err := checkTag(*filter.Tag)
		if err != nil {
			return err
		}
	}

	if fields > 1 {
		return fmt.Errorf("filter cannot have more than one field")
	}

	return nil
}