280 lines
8.2 KiB
Go
280 lines
8.2 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/spf13/cobra"
|
|
|
|
"git.cer.sh/axodouble/quptime/internal/config"
|
|
"git.cer.sh/axodouble/quptime/internal/daemon"
|
|
"git.cer.sh/axodouble/quptime/internal/transport"
|
|
)
|
|
|
|
func addCheckCmd(root *cobra.Command) {
|
|
check := &cobra.Command{
|
|
Use: "check",
|
|
Short: "Manage configured checks",
|
|
}
|
|
|
|
addHTTP := buildAddCheckCmd(config.CheckHTTP, "http", "<name> <url>",
|
|
"Add an HTTP/HTTPS check",
|
|
func(args []string, c *config.Check) error {
|
|
c.Name = args[0]
|
|
c.Target = args[1]
|
|
return nil
|
|
})
|
|
addHTTP.Flags().Int("expect", 200, "HTTP status code that signals UP")
|
|
addHTTP.Flags().String("body-match", "", "substring required in response body for UP")
|
|
|
|
addTCP := buildAddCheckCmd(config.CheckTCP, "tcp", "<name> <host:port>",
|
|
"Add a TCP-connect check",
|
|
func(args []string, c *config.Check) error {
|
|
c.Name = args[0]
|
|
c.Target = args[1]
|
|
return nil
|
|
})
|
|
|
|
addICMP := buildAddCheckCmd(config.CheckICMP, "icmp", "<name> <host>",
|
|
"Add an ICMP ping check",
|
|
func(args []string, c *config.Check) error {
|
|
c.Name = args[0]
|
|
c.Target = args[1]
|
|
return nil
|
|
})
|
|
|
|
addParent := &cobra.Command{
|
|
Use: "add",
|
|
Short: "Add a new check",
|
|
}
|
|
addParent.AddCommand(addHTTP, addTCP, addICMP)
|
|
|
|
listCmd := &cobra.Command{
|
|
Use: "list",
|
|
Short: "List configured checks and their current aggregate state",
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 10*time.Second)
|
|
defer cancel()
|
|
return runStatusPrintChecks(ctx, cmd)
|
|
},
|
|
}
|
|
|
|
removeCmd := &cobra.Command{
|
|
Use: "remove <id-or-name>",
|
|
Short: "Remove a configured check",
|
|
Args: cobra.ExactArgs(1),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 10*time.Second)
|
|
defer cancel()
|
|
body := daemon.MutateBody{Kind: transport.MutationRemoveCheck}
|
|
payload, _ := json.Marshal(args[0])
|
|
body.Payload = payload
|
|
raw, err := callDaemon(ctx, daemon.CtrlMutate, body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var res daemon.MutateResult
|
|
_ = json.Unmarshal(raw, &res)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "removed check %s (cluster version now %d)\n", args[0], res.Version)
|
|
return nil
|
|
},
|
|
}
|
|
|
|
check.AddCommand(addParent, listCmd, removeCmd, buildCheckEditCmd())
|
|
root.AddCommand(check)
|
|
}
|
|
|
|
// buildCheckEditCmd returns `qu check edit`, which updates fields of an
|
|
// existing check in place. Only flags that the operator actually passes
|
|
// modify the corresponding field — everything else is preserved from the
|
|
// existing record, including the ID. Identity match is by ID or Name.
|
|
func buildCheckEditCmd() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "edit <id-or-name>",
|
|
Short: "Update fields of an existing check",
|
|
Long: `Update one or more fields of an existing check.
|
|
|
|
Identifies the target by ID or Name. Only flags you pass take effect;
|
|
all other fields are preserved from the existing record. HTTP-only flags
|
|
(--expect, --body-match) error out on non-HTTP checks.`,
|
|
Args: cobra.ExactArgs(1),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
cluster, err := config.LoadClusterConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
snap := cluster.Snapshot()
|
|
var existing *config.Check
|
|
for i := range snap.Checks {
|
|
if snap.Checks[i].ID == args[0] || snap.Checks[i].Name == args[0] {
|
|
cp := snap.Checks[i]
|
|
existing = &cp
|
|
break
|
|
}
|
|
}
|
|
if existing == nil {
|
|
return fmt.Errorf("no check named %q", args[0])
|
|
}
|
|
|
|
f := cmd.Flags()
|
|
if f.Changed("name") {
|
|
v, _ := f.GetString("name")
|
|
existing.Name = strings.TrimSpace(v)
|
|
}
|
|
if f.Changed("target") {
|
|
v, _ := f.GetString("target")
|
|
existing.Target = strings.TrimSpace(v)
|
|
}
|
|
if f.Changed("interval") {
|
|
s, _ := f.GetString("interval")
|
|
d, err := time.ParseDuration(s)
|
|
if err != nil {
|
|
return fmt.Errorf("--interval: %w", err)
|
|
}
|
|
existing.Interval = d
|
|
}
|
|
if f.Changed("timeout") {
|
|
s, _ := f.GetString("timeout")
|
|
d, err := time.ParseDuration(s)
|
|
if err != nil {
|
|
return fmt.Errorf("--timeout: %w", err)
|
|
}
|
|
existing.Timeout = d
|
|
}
|
|
if f.Changed("alerts") {
|
|
csv, _ := f.GetString("alerts")
|
|
existing.AlertIDs = nil
|
|
for _, p := range strings.Split(csv, ",") {
|
|
p = strings.TrimSpace(p)
|
|
if p != "" {
|
|
existing.AlertIDs = append(existing.AlertIDs, p)
|
|
}
|
|
}
|
|
}
|
|
if f.Changed("expect") {
|
|
if existing.Type != config.CheckHTTP {
|
|
return fmt.Errorf("--expect only applies to HTTP checks (this is %s)", existing.Type)
|
|
}
|
|
v, _ := f.GetInt("expect")
|
|
existing.ExpectStatus = v
|
|
}
|
|
if f.Changed("body-match") {
|
|
if existing.Type != config.CheckHTTP {
|
|
return fmt.Errorf("--body-match only applies to HTTP checks (this is %s)", existing.Type)
|
|
}
|
|
v, _ := f.GetString("body-match")
|
|
existing.BodyMatch = v
|
|
}
|
|
|
|
payload, err := json.Marshal(existing)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body := daemon.MutateBody{Kind: transport.MutationAddCheck, Payload: payload}
|
|
raw, err := callDaemon(ctx, daemon.CtrlMutate, body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var res daemon.MutateResult
|
|
_ = json.Unmarshal(raw, &res)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "updated check %s (cluster version now %d)\n", existing.Name, res.Version)
|
|
return nil
|
|
},
|
|
}
|
|
cmd.Flags().String("name", "", "rename the check")
|
|
cmd.Flags().String("target", "", "new probe target (URL, host:port, or host)")
|
|
cmd.Flags().String("interval", "", "new probe interval (e.g. 30s, 1m)")
|
|
cmd.Flags().String("timeout", "", "new per-probe timeout (e.g. 10s)")
|
|
cmd.Flags().String("alerts", "", "replace alert list with this CSV of IDs/names (pass empty to clear)")
|
|
cmd.Flags().Int("expect", 0, "expected HTTP status code (HTTP only)")
|
|
cmd.Flags().String("body-match", "", "substring required in body (HTTP only)")
|
|
return cmd
|
|
}
|
|
|
|
// buildAddCheckCmd produces the per-type "qu check add <type>" subcommand.
|
|
func buildAddCheckCmd(ctype config.CheckType, use, argSpec, short string,
|
|
bind func(args []string, c *config.Check) error,
|
|
) *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: use + " " + argSpec,
|
|
Short: short,
|
|
Args: cobra.ExactArgs(2),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 10*time.Second)
|
|
defer cancel()
|
|
ch := config.Check{
|
|
ID: uuid.NewString(),
|
|
Type: ctype,
|
|
}
|
|
if err := bind(args, &ch); err != nil {
|
|
return err
|
|
}
|
|
intervalStr, _ := cmd.Flags().GetString("interval")
|
|
timeoutStr, _ := cmd.Flags().GetString("timeout")
|
|
alertsCSV, _ := cmd.Flags().GetString("alerts")
|
|
if intervalStr != "" {
|
|
d, err := time.ParseDuration(intervalStr)
|
|
if err != nil {
|
|
return fmt.Errorf("--interval: %w", err)
|
|
}
|
|
ch.Interval = d
|
|
} else {
|
|
ch.Interval = 30 * time.Second
|
|
}
|
|
if timeoutStr != "" {
|
|
d, err := time.ParseDuration(timeoutStr)
|
|
if err != nil {
|
|
return fmt.Errorf("--timeout: %w", err)
|
|
}
|
|
ch.Timeout = d
|
|
} else {
|
|
ch.Timeout = 10 * time.Second
|
|
}
|
|
if alertsCSV != "" {
|
|
for _, p := range strings.Split(alertsCSV, ",") {
|
|
p = strings.TrimSpace(p)
|
|
if p != "" {
|
|
ch.AlertIDs = append(ch.AlertIDs, p)
|
|
}
|
|
}
|
|
}
|
|
if ctype == config.CheckHTTP {
|
|
es, _ := cmd.Flags().GetInt("expect")
|
|
bm, _ := cmd.Flags().GetString("body-match")
|
|
ch.ExpectStatus = es
|
|
ch.BodyMatch = bm
|
|
}
|
|
|
|
payload, err := json.Marshal(ch)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body := daemon.MutateBody{Kind: transport.MutationAddCheck, Payload: payload}
|
|
raw, err := callDaemon(ctx, daemon.CtrlMutate, body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var res daemon.MutateResult
|
|
_ = json.Unmarshal(raw, &res)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "added check %s (%s) id=%s — cluster version %d\n",
|
|
ch.Name, ch.Type, ch.ID, res.Version)
|
|
return nil
|
|
},
|
|
}
|
|
bindCheckFlags(cmd)
|
|
return cmd
|
|
}
|
|
|
|
func bindCheckFlags(cmd *cobra.Command) {
|
|
cmd.Flags().String("interval", "30s", "probe interval")
|
|
cmd.Flags().String("timeout", "10s", "per-probe timeout")
|
|
cmd.Flags().String("alerts", "", "comma-separated alert IDs/names to notify on transition")
|
|
}
|