package main import ( "errors" "fmt" "math" "os" "os/exec" "regexp" "strconv" "strings" "syscall" ) const btrfsMagic = 0x9123683E var ( ErrStorageFull = errors.New("not enough storage left on the drives") ErrStorageTooBig = errors.New("above the storage limit") ErrMinOverMax = errors.New("the guaranteed amount can't be more than the max") ErrBelowUsage = errors.New("below what's already in use") ErrStorageTooSmall = errors.New("too small") ) const MinStorageMB = 512 type StorageConfig struct { Min string `toml:"min"` Max string `toml:"max"` Limit string `toml:"limit"` MinMB, MaxMB, LimitMB int64 `toml:"-"` } type DriveConfig struct { Path string `toml:"path"` Reserve string `toml:"reserve"` ReserveMB int64 `toml:"-"` } var storageToken = regexp.MustCompile(`^([+-]?)(\d+(?:\.\d+)?)(tib|tb|t|gib|gb|g|mib|mb|m)$`) func parseSizeMB(s string) (int64, error) { t := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(s), " ", "")) p := storageToken.FindStringSubmatch(t) if p == nil || p[1] != "" { return 0, fmt.Errorf("%q isn't a size like 5G or 500M", s) } return toMB(p[2], p[3]), nil } func toMB(num, unit string) int64 { n, _ := strconv.ParseFloat(num, 64) switch unit[0] { case 't': n *= 1024 * 1024 case 'g': n *= 1024 } return int64(math.Round(n)) } func formatMB(mb int64) string { trim := func(f float64) string { return strconv.FormatFloat(math.Round(f*10)/10, 'f', -1, 64) } switch { case mb >= 1024*1024: return trim(float64(mb)/(1024*1024)) + " TB" case mb >= 1024: return trim(float64(mb)/1024) + " GB" } return fmt.Sprintf("%d MB", mb) } func parseStorage(args string, curMin, curMax int64) (min, max int64, err error) { args = unitSpace.ReplaceAllString(strings.ToLower(args), "$1$2") words := strings.Fields(args) min, max = curMin, curMax var minDone, maxDone bool for i := 0; i < len(words); i++ { target := "max" switch words[i] { case "min", "guarantee", "guaranteed", "reserve": target = "min" i++ case "max", "cap", "limit": i++ } if i >= len(words) { return curMin, curMax, fmt.Errorf("%s needs a size after it, like `%s 10G`", target, target) } p := storageToken.FindStringSubmatch(words[i]) if p == nil { if i == 0 { return curMin, curMax, errNotCommand } return curMin, curMax, fmt.Errorf("I didn't understand `%s`", words[i]) } n := toMB(p[2], p[3]) if target == "min" { if minDone { return curMin, curMax, errors.New("min was given twice") } minDone = true min = int64(apply(p[1], float64(curMin), float64(n))) } else { if maxDone { return curMin, curMax, errors.New("max was given twice") } maxDone = true max = int64(apply(p[1], float64(curMax), float64(n))) } } return min, max, nil } type DriveReport struct { Path string UsableMB int64 CommittedMB int64 BookedMB int64 Homes int } func (d DriveReport) HeadroomMB() int64 { return d.UsableMB - d.CommittedMB } func (d DriveReport) Overbooked() bool { return d.BookedMB > d.UsableMB } func committed(minMB, usedMB int64) int64 { return max(minMB, usedMB) } func pickDrive(reports []DriveReport, needMB int64) (string, error) { best := -1 for i, r := range reports { if r.HeadroomMB() >= needMB && (best < 0 || r.HeadroomMB() > reports[best].HeadroomMB()) { best = i } } if best < 0 { return "", ErrStorageFull } return reports[best].Path, nil } func prepareDrive(path string) error { if err := os.MkdirAll(path, 0o700); err != nil { return err } var st syscall.Statfs_t if err := syscall.Statfs(path, &st); err != nil { return err } if uint32(st.Type) != btrfsMagic { return fmt.Errorf("%s is not on a btrfs filesystem", path) } if out, err := exec.Command("btrfs", "quota", "enable", path).CombinedOutput(); err != nil { return fmt.Errorf("turning on btrfs quotas for %s: %v: %s", path, err, strings.TrimSpace(string(out))) } return nil } func freeMB(path string) (int64, error) { var st syscall.Statfs_t if err := syscall.Statfs(path, &st); err != nil { return 0, err } return int64(st.Bavail) * int64(st.Bsize) / (1 << 20), nil } func createSubvolume(path string) error { if out, err := exec.Command("btrfs", "subvolume", "create", path).CombinedOutput(); err != nil { return fmt.Errorf("creating %s: %v: %s", path, err, strings.TrimSpace(string(out))) } return nil } func setQuota(path string, mb int64) error { bytes := strconv.FormatInt(mb<<20, 10) if out, err := exec.Command("btrfs", "qgroup", "limit", bytes, path).CombinedOutput(); err != nil { return fmt.Errorf("setting quota on %s: %v: %s", path, err, strings.TrimSpace(string(out))) } return nil } // Quota numbers can lag a few seconds behind writes. func usedMB(path string) (int64, error) { out, err := exec.Command("btrfs", "qgroup", "show", "-f", "--raw", path).CombinedOutput() if err != nil { return 0, fmt.Errorf("reading usage of %s: %v: %s", path, err, strings.TrimSpace(string(out))) } return parseQgroupShow(string(out)) } // Parses `btrfs qgroup show --raw`: "0/257 ...". func parseQgroupShow(out string) (int64, error) { for _, line := range strings.Split(out, "\n") { f := strings.Fields(line) if len(f) >= 2 && strings.HasPrefix(f[0], "0/") { b, err := strconv.ParseInt(f[1], 10, 64) if err != nil { return 0, err } return b >> 20, nil } } return 0, errors.New("no quota group found") }