Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

3.6 KB
Raw Blame
package shell

import (
	"context"
	"flag"
	"fmt"
	"io"

	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
	"github.com/seaweedfs/seaweedfs/weed/s3api/s3bucket"
)

func init() {
	Commands = append(Commands, &commandS3BucketLifecycleFastpath{})
}

type commandS3BucketLifecycleFastpath struct {
}

func (c *commandS3BucketLifecycleFastpath) Name() string {
	return "s3.bucket.lifecycle.fastpath"
}

func (c *commandS3BucketLifecycleFastpath) Help() string {
	return `view or toggle the per-bucket lifecycle TTL fast path

	When enabled, an Expiration.Days lifecycle rule is stamped as a volume
	TTL at PutObject time, so the volume server reclaims the data on its own
	and the lifecycle worker skips per-chunk deletes. Off by default: a
	volume TTL is baked into the object at write time and can't honor a later
	policy change (rule removed or lengthened), unlike worker-driven
	expiration. The fast path never applies to versioned or object-locked
	buckets regardless of this flag.

	Example:
		# Show the current setting
		s3.bucket.lifecycle.fastpath -name <bucket_name>

		# Enable
		s3.bucket.lifecycle.fastpath -name <bucket_name> -enable

		# Disable
		s3.bucket.lifecycle.fastpath -name <bucket_name> -disable
`
}

func (c *commandS3BucketLifecycleFastpath) HasTag(CommandTag) bool {
	return false
}

func (c *commandS3BucketLifecycleFastpath) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
	bucketCommand := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
	bucketName := bucketCommand.String("name", "", "bucket name")
	enable := bucketCommand.Bool("enable", false, "enable the lifecycle TTL fast path")
	disable := bucketCommand.Bool("disable", false, "disable the lifecycle TTL fast path")
	if err = bucketCommand.Parse(args); err != nil {
		return err
	}

	if *bucketName == "" {
		return fmt.Errorf("empty bucket name")
	}
	if err := s3bucket.VerifyS3BucketName(*bucketName); err != nil {
		return fmt.Errorf("invalid bucket name %q: %w", *bucketName, err)
	}
	if *enable && *disable {
		return fmt.Errorf("only one of -enable or -disable can be set")
	}

	return commandEnv.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
		resp, err := client.GetFilerConfiguration(context.Background(), &filer_pb.GetFilerConfigurationRequest{})
		if err != nil {
			return fmt.Errorf("get filer configuration: %w", err)
		}
		filerBucketsPath := resp.DirBuckets

		lookupResp, err := client.LookupDirectoryEntry(context.Background(), &filer_pb.LookupDirectoryEntryRequest{
			Directory: filerBucketsPath,
			Name:      *bucketName,
		})
		if err != nil {
			return fmt.Errorf("lookup bucket %s: %w", *bucketName, err)
		}
		entry := lookupResp.Entry

		if !*enable && !*disable {
			state := "disabled"
			if string(entry.Extended[s3_constants.ExtLifecycleTtlFastPathKey]) == "true" {
				state = "enabled"
			}
			fmt.Fprintf(writer, "Bucket: %s\n", *bucketName)
			fmt.Fprintf(writer, "Lifecycle TTL fast path: %s\n", state)
			return nil
		}

		if entry.Extended == nil {
			entry.Extended = make(map[string][]byte)
		}
		state := "disabled"
		if *enable {
			entry.Extended[s3_constants.ExtLifecycleTtlFastPathKey] = []byte("true")
			state = "enabled"
		} else {
			delete(entry.Extended, s3_constants.ExtLifecycleTtlFastPathKey)
		}

		if _, err := client.UpdateEntry(context.Background(), &filer_pb.UpdateEntryRequest{
			Directory: filerBucketsPath,
			Entry:     entry,
		}); err != nil {
			return fmt.Errorf("failed to update bucket: %w", err)
		}

		fmt.Fprintf(writer, "Bucket %s lifecycle TTL fast path %s\n", *bucketName, state)
		return nil
	})
}