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.

2.9 KB
Raw Blame
package util

import (
	"errors"
	"fmt"
	"strconv"
	"strings"

	"github.com/seaweedfs/seaweedfs/weed/glog"
)

// MinFreeSpaceType is the type of MinFreeSpace.
type MinFreeSpaceType int

const (
	// AsPercent set the MinFreeSpaceType to a percentage value from 0 to 100.
	AsPercent MinFreeSpaceType = iota
	// AsBytes set the MinFreeSpaceType to a absolute value bytes.
	AsBytes
)

// MinFreeSpace is type that defines the limit for the minimum free space.
type MinFreeSpace struct {
	Type    MinFreeSpaceType
	Bytes   uint64
	Percent float32
	Raw     string
}

// IsLow tells whether the free space is low or not.
func (s MinFreeSpace) IsLow(freeBytes uint64, freePercent float32) (yes bool, desc string) {
	switch s.Type {
	case AsPercent:
		yes = freePercent < s.Percent
		op := IfElse(yes, "<", ">=")
		return yes, fmt.Sprintf("disk free %.2f%% %s required %.2f%%", freePercent, op, s.Percent)
	case AsBytes:
		yes = freeBytes < s.Bytes
		op := IfElse(yes, "<", ">=")
		return yes, fmt.Sprintf("disk free %s %s required %s",
			BytesToHumanReadable(freeBytes), op, BytesToHumanReadable(s.Bytes))
	}

	return false, ""
}

func (s MinFreeSpace) AvailableSpace(freeBytes uint64, totalBytes uint64) uint64 {
	var minFreeSpaceBytes uint64
	switch s.Type {
	case AsPercent:
		minFreeSpaceBytes = uint64((float32(totalBytes) * s.Percent) / 100)
	case AsBytes:
		minFreeSpaceBytes = s.Bytes
	}
	if minFreeSpaceBytes > freeBytes {
		return 0
	}
	return freeBytes - minFreeSpaceBytes
}

// String returns a string representation of MinFreeSpace.
func (s MinFreeSpace) String() string {
	switch s.Type {
	case AsPercent:
		return fmt.Sprintf("%.2f%%", s.Percent)
	default:
		return s.Raw
	}
}

// MustParseMinFreeSpace parses comma-separated argument for min free space setting.
// minFreeSpace has the high priority than minFreeSpacePercent if it is set.
func MustParseMinFreeSpace(minFreeSpace string, minFreeSpacePercent string) (spaces []MinFreeSpace) {
	ss := strings.Split(EmptyTo(minFreeSpace, minFreeSpacePercent), ",")
	for _, freeString := range ss {
		if vv, e := ParseMinFreeSpace(freeString); e == nil {
			spaces = append(spaces, *vv)
		} else {
			glog.Fatalf("The value specified in -minFreeSpace not a valid value %s", freeString)
		}
	}

	return spaces
}

var ErrMinFreeSpaceBadValue = errors.New("minFreeSpace is invalid")

// ParseMinFreeSpace parses min free space expression s as percentage like 1,10 or human readable size like 10G
func ParseMinFreeSpace(s string) (*MinFreeSpace, error) {
	s = strings.TrimSpace(s)
	if percent, e := strconv.ParseFloat(s, 32); e == nil {
		if percent < 0 || percent > 100 {
			return nil, ErrMinFreeSpaceBadValue
		}
		return &MinFreeSpace{Type: AsPercent, Percent: float32(percent), Raw: s}, nil
	}

	if directSize, e := ParseBytes(s); e == nil {
		if directSize <= 100 {
			return nil, ErrMinFreeSpaceBadValue
		}
		return &MinFreeSpace{Type: AsBytes, Bytes: directSize, Raw: s}, nil
	}

	return nil, ErrMinFreeSpaceBadValue
}