package commands import ( "errors" "fmt" "math" "regexp" "slices" "strconv" "strings" "time" "slackerbot/internal/model" "slackerbot/internal/units" ) var ErrNotCommand = errors.New("not a command") var unitSpace = regexp.MustCompile(`(\d)\s+(tib|tb|t|gib|gb|g|mib|mb|m|cpus|cpu|cores|core)\b`) var sizeToken = regexp.MustCompile(`^([+-]?)(\d+(?:\.\d+)?)(g|gb|gib|m|mb|mib|cpu|cpus|core|cores)$`) func ParseScale(args string, cur model.Size) (model.Size, error) { args = unitSpace.ReplaceAllString(strings.ToLower(args), "$1$2") words := strings.Fields(args) if len(words) == 0 { return model.Size{MemoryMB: cur.MemoryMB * 2, CPUs: cur.CPUs * 2}, nil } if len(words) == 1 { switch words[0] { case "up", "out": return model.Size{MemoryMB: cur.MemoryMB * 2, CPUs: cur.CPUs * 2}, nil case "down", "in": return model.Size{MemoryMB: cur.MemoryMB / 2, CPUs: cur.CPUs / 2}, nil } } next := cur var memDone, cpuDone bool for i, w := range words { parts := sizeToken.FindStringSubmatch(w) if parts == nil { if i == 0 { return cur, ErrNotCommand } return cur, fmt.Errorf("I didn't understand `%s`", w) } sign, num, unit := parts[1], parts[2], parts[3] n, _ := strconv.ParseFloat(num, 64) if unit == "cpu" || unit == "cpus" || unit == "core" || unit == "cores" { if cpuDone { return cur, errors.New("CPU was given twice") } cpuDone = true next.CPUs = apply(sign, cur.CPUs, n) continue } if memDone { return cur, errors.New("memory was given twice") } memDone = true mb := n if strings.HasPrefix(unit, "g") { mb = n * 1024 } next.MemoryMB = int(math.Round(apply(sign, float64(cur.MemoryMB), mb))) } return next, nil } func apply(sign string, cur, n float64) float64 { switch sign { case "+": return cur + n case "-": return cur - n } return n } type KeepSetting struct { Show bool Reset bool Indefinite bool Limit time.Duration } var dayToken = regexp.MustCompile(`(\d+(?:\.\d+)?)([dw])`) var wordUnit = regexp.MustCompile(`(\d+(?:\.\d+)?)\s*(weeks?|wks?|days?|hours?|hrs?|minutes?|mins?)\b`) func ParseKeep(args string) (KeepSetting, error) { a := strings.ToLower(strings.TrimSpace(args)) switch a { case "": return KeepSetting{Show: true}, nil case "default", "reset", "normal": return KeepSetting{Reset: true}, nil case "indefinite", "indefinitely", "forever", "alive", "running", "on": return KeepSetting{Indefinite: true}, nil } d, err := parseDuration(a) if err != nil { return KeepSetting{}, ErrNotCommand } if d <= 0 { return KeepSetting{}, errors.New("the time has to be more than zero") } return KeepSetting{Limit: d}, nil } func parseDuration(s string) (time.Duration, error) { s = wordUnit.ReplaceAllStringFunc(s, func(m string) string { p := wordUnit.FindStringSubmatch(m) return p[1] + map[byte]string{'w': "w", 'd': "d", 'h': "h", 'm': "m"}[p[2][0]] }) s = strings.ReplaceAll(s, " ", "") s = dayToken.ReplaceAllStringFunc(s, func(m string) string { p := dayToken.FindStringSubmatch(m) n, _ := strconv.ParseFloat(p[1], 64) hours := n * 24 if p[2] == "w" { hours = n * 24 * 7 } return strconv.FormatFloat(hours, 'f', -1, 64) + "h" }) return time.ParseDuration(s) } func Human(d time.Duration) string { d = d.Round(time.Minute) days := d / (24 * time.Hour) d -= days * 24 * time.Hour out := "" if days > 0 { out = fmt.Sprintf("%dd", days) } if d > 0 { r := strings.TrimSuffix(d.String(), "0s") if strings.HasSuffix(r, "h0m") { r = strings.TrimSuffix(r, "0m") } out += r } if out == "" { out = "0m" } return out } 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 := units.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 := units.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 } var mentionRe = regexp.MustCompile(`^<@([UW][A-Z0-9]+)(?:\|[^>]*)?>[,.]?$`) type GrantCmd struct { ToDefault bool Users []string Actions []model.Action } func ParseGrant(args string) (GrantCmd, error) { var g GrantCmd words := strings.Fields(args) i := 0 if len(words) > 0 && strings.ToLower(words[0]) == "default" { g.ToDefault, i = true, 1 } for ; i < len(words); i++ { if m := mentionRe.FindStringSubmatch(words[i]); m != nil { g.Users = append(g.Users, m[1]) continue } w := strings.ToLower(strings.Trim(words[i], ",.")) if w == "all" || slices.Contains(model.GrantActions, model.Action(w)) { g.Actions = append(g.Actions, model.Action(w)) continue } if len(g.Users) == 0 && !g.ToDefault { return g, ErrNotCommand } return g, fmt.Errorf("I didn't understand `%s`", words[i]) } switch { case len(g.Users) == 0 && !g.ToDefault: return g, ErrNotCommand case len(g.Users) == 0: return g, errors.New("name at least one person, like `grant default @alice all`") } return g, nil } func ParseToggle(word string) (on, ok bool) { switch strings.ToLower(word) { case "on", "yes", "true", "allow", "allowed", "enable": return true, true case "off", "no", "false", "deny", "denied", "disable": return false, true } return false, false } func NeededPermission(verb, args string) model.Action { switch verb { case "scale": if _, err := ParseScale(args, model.Size{MemoryMB: 1024, CPUs: 1}); !errors.Is(err, ErrNotCommand) { return model.ActScale } case "keep": if k, err := ParseKeep(args); !errors.Is(err, ErrNotCommand) && !k.Show { return model.ActKeep } case "storage", "disk": if args == "" { return "" } if _, _, err := ParseStorage(args, 1024, 1024); !errors.Is(err, ErrNotCommand) { return model.ActStorage } } return "" }