jochen
9582208984
Both are official packages already on both workstations, started once by dex from an XDG autostart entry (the client's own, the package's). The modules declare the package, add no second start, own none of the apps' files, and give the mesh status, log, restart and check.
98 lines
2.4 KiB
Go
98 lines
2.4 KiB
Go
// Reading a tool's arguments: JSON numbers arrive as float64, and a missing argument is its default.
|
|
// The same in every desktop module that carries it.
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// text is a string argument, trimmed; required says an empty one is refused.
|
|
func text(args map[string]any, key string, required bool) (string, error) {
|
|
v, present := args[key]
|
|
if !present || v == nil {
|
|
if required {
|
|
return "", fmt.Errorf("%s is required", key)
|
|
}
|
|
return "", nil
|
|
}
|
|
s, ok := v.(string)
|
|
if !ok {
|
|
return "", fmt.Errorf("%s is a string, not %T", key, v)
|
|
}
|
|
s = strings.TrimSpace(s)
|
|
if s == "" && required {
|
|
return "", fmt.Errorf("%s is required", key)
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// whole is a whole-number argument within [least, most], or def when absent.
|
|
func whole(args map[string]any, key string, def, least, most int) (int, error) {
|
|
v, present := args[key]
|
|
if !present || v == nil {
|
|
return def, nil
|
|
}
|
|
f, ok := v.(float64)
|
|
if !ok {
|
|
if i, isInt := v.(int); isInt {
|
|
f = float64(i)
|
|
} else {
|
|
return 0, fmt.Errorf("%s is a number, not %T", key, v)
|
|
}
|
|
}
|
|
if f != math.Trunc(f) {
|
|
return 0, fmt.Errorf("%s is a whole number, not %v", key, f)
|
|
}
|
|
n := int(f)
|
|
if n < least || n > most {
|
|
return 0, fmt.Errorf("%s is %d; it is between %d and %d", key, n, least, most)
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
// flag is a boolean argument, or def when absent.
|
|
func flag(args map[string]any, key string, def bool) (bool, error) {
|
|
v, present := args[key]
|
|
if !present || v == nil {
|
|
return def, nil
|
|
}
|
|
b, ok := v.(bool)
|
|
if !ok {
|
|
return false, fmt.Errorf("%s is true or false, not %T", key, v)
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
// texts is a list-of-strings argument.
|
|
func texts(args map[string]any, key string) ([]string, error) {
|
|
v, present := args[key]
|
|
if !present || v == nil {
|
|
return nil, nil
|
|
}
|
|
list, ok := v.([]any)
|
|
if !ok {
|
|
if ss, isStrings := v.([]string); isStrings {
|
|
return ss, nil
|
|
}
|
|
return nil, fmt.Errorf("%s is a list of strings, not %T", key, v)
|
|
}
|
|
out := make([]string, 0, len(list))
|
|
for i, item := range list {
|
|
s, ok := item.(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("%s[%d] is a string, not %T", key, i, item)
|
|
}
|
|
out = append(out, s)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// seconds is a timeout argument in seconds, defaulted and bounded below the runtime's call limit.
|
|
func seconds(args map[string]any, key string, def, most int) (time.Duration, error) {
|
|
n, err := whole(args, key, def, 1, most)
|
|
return time.Duration(n) * time.Second, err
|
|
}
|