Pim van Pelt
bc6ccaa844
Bump VERSION to 1.0.0 and cut the first tagged release of vpp-maglev. Also in this commit: - maglevc: MAGLEV_SERVER env var as an alternative to the --server flag, matching the MAGLEV_CONFIG / MAGLEV_GRPC_ADDR convention on the other binaries. The flag takes precedence when both are set. - Rename cmd/maglevd -> cmd/server and cmd/maglevc -> cmd/client so the source directory names are decoupled from binary names (the frontend and tester commands already followed this convention). Build outputs and the Debian packages are unchanged.
807 lines
26 KiB
Go
807 lines
26 KiB
Go
// Copyright (c) 2026, Pim van Pelt <pim@ipng.ch>
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"text/tabwriter"
|
|
"time"
|
|
|
|
buildinfo "git.ipng.ch/ipng/vpp-maglev/cmd"
|
|
"git.ipng.ch/ipng/vpp-maglev/internal/grpcapi"
|
|
)
|
|
|
|
const callTimeout = 10 * time.Second
|
|
|
|
// buildTree constructs the full command tree.
|
|
func buildTree() *Node {
|
|
root := &Node{Word: "", Help: ""}
|
|
|
|
show := &Node{Word: "show", Help: "show information"}
|
|
set := &Node{Word: "set", Help: "modify configuration"}
|
|
quit := &Node{Word: "quit", Help: "exit the shell", Run: runQuit}
|
|
exit := &Node{Word: "exit", Help: "exit the shell", Run: runQuit}
|
|
|
|
// show version
|
|
showVersion := &Node{Word: "version", Help: "Show build version", Run: runShowVersion}
|
|
|
|
// show frontends [<name>] — without name: list all, with name: show details
|
|
showFrontendName := &Node{
|
|
Word: "<name>",
|
|
Help: "Show details for a single frontend",
|
|
Dynamic: dynFrontends,
|
|
Run: runShowFrontend,
|
|
}
|
|
showFrontends := &Node{
|
|
Word: "frontends",
|
|
Help: "List all frontends",
|
|
Run: runShowFrontends,
|
|
Children: []*Node{showFrontendName},
|
|
}
|
|
|
|
// show backends [<name>] — without name: list all, with name: show details
|
|
showBackendName := &Node{
|
|
Word: "<name>",
|
|
Help: "Show details for a single backend",
|
|
Dynamic: dynBackends,
|
|
Run: runShowBackend,
|
|
}
|
|
showBackends := &Node{
|
|
Word: "backends",
|
|
Help: "List all backends",
|
|
Run: runShowBackends,
|
|
Children: []*Node{showBackendName},
|
|
}
|
|
|
|
// show healthchecks [<name>] — without name: list all, with name: show details
|
|
showHealthCheckName := &Node{
|
|
Word: "<name>",
|
|
Help: "Show details for a single health check",
|
|
Dynamic: dynHealthChecks,
|
|
Run: runShowHealthCheck,
|
|
}
|
|
showHealthChecks := &Node{
|
|
Word: "healthchecks",
|
|
Help: "List all health checks",
|
|
Run: runShowHealthChecks,
|
|
Children: []*Node{showHealthCheckName},
|
|
}
|
|
|
|
// show vpp info / lb state / lb counters
|
|
showVPPInfo := &Node{Word: "info", Help: "Show VPP version, uptime, and connection status", Run: runShowVPPInfo}
|
|
showVPPLBState := &Node{Word: "state", Help: "Show VPP load-balancer state (VIPs and application servers)", Run: runShowVPPLBState}
|
|
showVPPLBCounters := &Node{Word: "counters", Help: "Show VPP per-VIP and per-backend packet/byte counters (refreshed every ~5s server-side)", Run: runShowVPPLBCounters}
|
|
showVPPLB := &Node{
|
|
Word: "lb",
|
|
Help: "VPP load-balancer information",
|
|
Children: []*Node{showVPPLBState, showVPPLBCounters},
|
|
}
|
|
showVPP := &Node{
|
|
Word: "vpp",
|
|
Help: "VPP dataplane information",
|
|
Children: []*Node{showVPPInfo, showVPPLB},
|
|
}
|
|
|
|
show.Children = []*Node{
|
|
showVersion,
|
|
showFrontends,
|
|
showBackends,
|
|
showHealthChecks,
|
|
showVPP,
|
|
}
|
|
|
|
// set backend <name> pause|resume|disabled|enabled
|
|
setPause := &Node{Word: "pause", Help: "pause health checking", Run: runPauseBackend}
|
|
setResume := &Node{Word: "resume", Help: "resume health checking", Run: runResumeBackend}
|
|
setDisabled := &Node{Word: "disable", Help: "disable backend (stop probing, remove from rotation)", Run: runDisableBackend}
|
|
setEnabled := &Node{Word: "enable", Help: "enable backend (resume probing)", Run: runEnableBackend}
|
|
setBackendName := &Node{
|
|
Word: "<name>",
|
|
Help: "backend name",
|
|
Dynamic: dynBackends,
|
|
Children: []*Node{setPause, setResume, setDisabled, setEnabled},
|
|
}
|
|
setBackend := &Node{
|
|
Word: "backend",
|
|
Help: "modify a backend",
|
|
Children: []*Node{setBackendName},
|
|
}
|
|
// set frontend <name> pool <pool> backend <name> weight <0-100> [flush]
|
|
//
|
|
// The tree walker only puts tokens from slot (Dynamic) nodes into
|
|
// args, so the literal "flush" keyword isn't visible in the arg
|
|
// list. We use two distinct Run functions to distinguish the two
|
|
// leaf paths instead — both share the same underlying helper.
|
|
setWeightFlush := &Node{
|
|
Word: "flush",
|
|
Help: "also drop VPP's flow table for this backend (otherwise only the new-buckets map is updated)",
|
|
Run: runSetFrontendPoolBackendWeightFlush,
|
|
}
|
|
setWeightValue := &Node{
|
|
Word: "<weight>",
|
|
Help: "Set weight of a backend in a pool (0-100)",
|
|
Dynamic: dynNone, // accepts any integer; no tab-completion candidates
|
|
Run: runSetFrontendPoolBackendWeight,
|
|
Children: []*Node{setWeightFlush},
|
|
}
|
|
setFrontendPoolBackendWeight := &Node{Word: "weight", Help: "set backend weight in pool", Children: []*Node{setWeightValue}}
|
|
setFrontendPoolBackendName := &Node{
|
|
Word: "<backend>",
|
|
Help: "backend name",
|
|
Dynamic: dynBackends,
|
|
Children: []*Node{setFrontendPoolBackendWeight},
|
|
}
|
|
setFrontendPoolBackend := &Node{Word: "backend", Help: "select a backend", Children: []*Node{setFrontendPoolBackendName}}
|
|
setFrontendPoolName := &Node{
|
|
Word: "<pool>",
|
|
Help: "pool name",
|
|
Dynamic: dynNone, // pool names aren't listed via gRPC; accepts any input
|
|
Children: []*Node{setFrontendPoolBackend},
|
|
}
|
|
setFrontendPool := &Node{Word: "pool", Help: "select a pool", Children: []*Node{setFrontendPoolName}}
|
|
setFrontendName := &Node{
|
|
Word: "<name>",
|
|
Help: "frontend name",
|
|
Dynamic: dynFrontends,
|
|
Children: []*Node{setFrontendPool},
|
|
}
|
|
setFrontend := &Node{
|
|
Word: "frontend",
|
|
Help: "modify a frontend",
|
|
Children: []*Node{setFrontendName},
|
|
}
|
|
|
|
set.Children = []*Node{setBackend, setFrontend}
|
|
|
|
// watch events [num <n>] [log [level <level>]] [backend] [frontend]
|
|
//
|
|
// All tokens after 'events' are captured as args via a self-referencing slot
|
|
// node. This lets runWatchEvents parse the optional flags manually while still
|
|
// providing tab-completion through the dynamic enumerator.
|
|
watchEventsOptSlot := &Node{
|
|
Word: "<opt>",
|
|
Help: "Stream events with options",
|
|
Dynamic: dynWatchEventOpts,
|
|
Run: runWatchEvents,
|
|
}
|
|
watchEventsOptSlot.Children = []*Node{watchEventsOptSlot}
|
|
|
|
watchEvents := &Node{
|
|
Word: "events",
|
|
Help: "stream events (press any key or Ctrl-C to stop)",
|
|
Run: runWatchEvents,
|
|
Children: []*Node{watchEventsOptSlot},
|
|
}
|
|
watch := &Node{
|
|
Word: "watch",
|
|
Help: "watch live event streams",
|
|
Children: []*Node{watchEvents},
|
|
}
|
|
|
|
// config check / reload
|
|
configCheck := &Node{Word: "check", Help: "Check configuration file", Run: runConfigCheck}
|
|
configReload := &Node{Word: "reload", Help: "Check and reload configuration", Run: runConfigReload}
|
|
configNode := &Node{
|
|
Word: "config",
|
|
Help: "configuration commands",
|
|
Children: []*Node{configCheck, configReload},
|
|
}
|
|
|
|
// sync vpp lb state [<name>]
|
|
//
|
|
// Without a name: run SyncLBStateAll (may remove stale VIPs).
|
|
// With a name: run SyncLBStateVIP(name) for just that frontend (no removals).
|
|
syncVPPLBStateName := &Node{
|
|
Word: "<name>",
|
|
Help: "Sync a single frontend's VIP to VPP",
|
|
Dynamic: dynFrontends,
|
|
Run: runSyncVPPLBState,
|
|
}
|
|
syncVPPLBState := &Node{
|
|
Word: "state",
|
|
Help: "Sync the VPP load-balancer dataplane from the running config",
|
|
Run: runSyncVPPLBState,
|
|
Children: []*Node{syncVPPLBStateName},
|
|
}
|
|
syncVPPLB := &Node{
|
|
Word: "lb",
|
|
Help: "VPP load-balancer sync commands",
|
|
Children: []*Node{syncVPPLBState},
|
|
}
|
|
syncVPP := &Node{
|
|
Word: "vpp",
|
|
Help: "VPP dataplane sync commands",
|
|
Children: []*Node{syncVPPLB},
|
|
}
|
|
syncNode := &Node{
|
|
Word: "sync",
|
|
Help: "Reconcile dataplane state from the running config",
|
|
Children: []*Node{syncVPP},
|
|
}
|
|
|
|
root.Children = []*Node{show, set, watch, configNode, syncNode, quit, exit}
|
|
return root
|
|
}
|
|
|
|
// ---- dynamic enumerators ---------------------------------------------------
|
|
|
|
func dynFrontends(ctx context.Context, client grpcapi.MaglevClient) []string {
|
|
resp, err := client.ListFrontends(ctx, &grpcapi.ListFrontendsRequest{})
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return resp.FrontendNames
|
|
}
|
|
|
|
func dynBackends(ctx context.Context, client grpcapi.MaglevClient) []string {
|
|
resp, err := client.ListBackends(ctx, &grpcapi.ListBackendsRequest{})
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return resp.BackendNames
|
|
}
|
|
|
|
func dynHealthChecks(ctx context.Context, client grpcapi.MaglevClient) []string {
|
|
resp, err := client.ListHealthChecks(ctx, &grpcapi.ListHealthChecksRequest{})
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return resp.Names
|
|
}
|
|
|
|
// dynNone marks a slot node that accepts any input but provides no
|
|
// tab-completion candidates (e.g. a pool name or numeric weight value).
|
|
func dynNone(_ context.Context, _ grpcapi.MaglevClient) []string { return nil }
|
|
|
|
// ---- run functions ---------------------------------------------------------
|
|
|
|
func runShowVPPInfo(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.GetVPPInfo(ctx, &grpcapi.GetVPPInfoRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("version"), info.Version)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("build-date"), info.BuildDate)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("build-dir"), info.BuildDirectory)
|
|
_, _ = fmt.Fprintf(w, "%s\t%d\n", label("vpp-pid"), info.Pid)
|
|
if info.BoottimeNs > 0 {
|
|
bootTime := time.Unix(0, info.BoottimeNs)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s (%s)\n", label("vpp-boottime"),
|
|
bootTime.Format("2006-01-02 15:04:05"),
|
|
formatDuration(time.Since(bootTime)))
|
|
}
|
|
connTime := time.Unix(0, info.ConnecttimeNs)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s (%s)\n", label("connected"),
|
|
connTime.Format("2006-01-02 15:04:05"),
|
|
formatDuration(time.Since(connTime)))
|
|
return w.Flush()
|
|
}
|
|
|
|
func runShowVPPLBState(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
state, err := client.GetVPPLBState(ctx, &grpcapi.GetVPPLBStateRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// ---- global config ----
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, "%s\n", label("global"))
|
|
if state.Conf.Ip4SrcAddress != "" {
|
|
_, _ = fmt.Fprintf(w, " %s\t%s\n", label("ip4-src"), state.Conf.Ip4SrcAddress)
|
|
}
|
|
if state.Conf.Ip6SrcAddress != "" {
|
|
_, _ = fmt.Fprintf(w, " %s\t%s\n", label("ip6-src"), state.Conf.Ip6SrcAddress)
|
|
}
|
|
_, _ = fmt.Fprintf(w, " %s\t%d\n", label("sticky-buckets-per-core"), state.Conf.StickyBucketsPerCore)
|
|
_, _ = fmt.Fprintf(w, " %s\t%ds\n", label("flow-timeout"), state.Conf.FlowTimeout)
|
|
if err := w.Flush(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(state.Vips) == 0 {
|
|
fmt.Println(label("vips") + " (none)")
|
|
return nil
|
|
}
|
|
|
|
// ---- per-VIP details ----
|
|
for _, v := range state.Vips {
|
|
fmt.Println()
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("vip"), stripHostMask(v.Prefix))
|
|
_, _ = fmt.Fprintf(w, " %s\t%s\n", label("protocol"), protoString(v.Protocol))
|
|
_, _ = fmt.Fprintf(w, " %s\t%d\n", label("port"), v.Port)
|
|
_, _ = fmt.Fprintf(w, " %s\t%s\n", label("encap"), v.Encap)
|
|
_, _ = fmt.Fprintf(w, " %s\t%t\n", label("src-ip-sticky"), v.SrcIpSticky)
|
|
_, _ = fmt.Fprintf(w, " %s\t%d\n", label("flow-table-length"), v.FlowTableLength)
|
|
_, _ = fmt.Fprintf(w, " %s\t%d\n", label("application-servers"), len(v.ApplicationServers))
|
|
if err := w.Flush(); err != nil {
|
|
return err
|
|
}
|
|
for _, a := range v.ApplicationServers {
|
|
fmt.Printf(" %s %s %s %d %s %d\n",
|
|
label("address"), a.Address,
|
|
label("weight"), a.Weight,
|
|
label("flow-table-buckets"), a.NumBuckets)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// runShowVPPLBCounters prints the per-VIP runtime counters captured by
|
|
// maglevd's 5s scrape loop. Values are up to 5 seconds stale; Prometheus
|
|
// is the right tool if you need live rates. There is no per-backend
|
|
// block — see internal/vpp/lbstats.go::scrapeLBStats for why VPP's LB
|
|
// plugin doesn't expose per-backend packet counters today.
|
|
func runShowVPPLBCounters(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
resp, err := client.GetVPPLBCounters(ctx, &grpcapi.GetVPPLBCountersRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(resp.Vips) == 0 {
|
|
fmt.Println("(no counters — VPP disconnected or scrape pending)")
|
|
return nil
|
|
}
|
|
|
|
// ---- frontend-counters ----
|
|
//
|
|
// Column headers are plain strings, not label()-wrapped. tabwriter
|
|
// counts bytes (not rendered width), so wrapping a header cell in
|
|
// ANSI escape codes inflates its apparent width by ~11 bytes and
|
|
// the data rows below — which are plain numeric strings — end up
|
|
// over-padded. The label() convention only works when every cell
|
|
// in a column shares the same wrapping, which the key-value show
|
|
// commands do but this table can't (we're not about to colourise
|
|
// every packet count).
|
|
fmt.Println(label("frontend-counters"))
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, " vip\tproto\tport\tfirst\tnext\tuntracked\tno-server\tfib-packets\tfib-bytes\n")
|
|
for _, v := range resp.Vips {
|
|
_, _ = fmt.Fprintf(w, " %s\t%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
|
|
stripHostMask(v.Prefix), v.Protocol, v.Port,
|
|
v.FirstPacket, v.NextPacket,
|
|
v.UntrackedPacket, v.NoServer,
|
|
v.Packets, v.Bytes,
|
|
)
|
|
}
|
|
return w.Flush()
|
|
}
|
|
|
|
// stripHostMask trims "/32" (IPv4) or "/128" (IPv6) from a VIP's CIDR
|
|
// string. maglevd only programs host-prefix VIPs so the mask is always
|
|
// one of these two values and carries no information for a human reader.
|
|
// Non-host prefixes and unparseable strings are returned unchanged so
|
|
// future changes don't silently lose data.
|
|
func stripHostMask(prefix string) string {
|
|
if strings.HasSuffix(prefix, "/32") || strings.HasSuffix(prefix, "/128") {
|
|
return prefix[:strings.LastIndexByte(prefix, '/')]
|
|
}
|
|
return prefix
|
|
}
|
|
|
|
// protoString renders an IP protocol number as a name (tcp, udp, any, or numeric).
|
|
func protoString(p uint32) string {
|
|
switch p {
|
|
case 6:
|
|
return "tcp"
|
|
case 17:
|
|
return "udp"
|
|
case 255:
|
|
return "any"
|
|
}
|
|
return fmt.Sprintf("%d", p)
|
|
}
|
|
|
|
func runSyncVPPLBState(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
req := &grpcapi.SyncVPPLBStateRequest{}
|
|
if len(args) > 0 && args[0] != "" {
|
|
name := args[0]
|
|
req.FrontendName = &name
|
|
}
|
|
if _, err := client.SyncVPPLBState(ctx, req); err != nil {
|
|
return err
|
|
}
|
|
if req.FrontendName != nil {
|
|
fmt.Printf("synced frontend %q to VPP\n", *req.FrontendName)
|
|
} else {
|
|
fmt.Println("synced full LB state to VPP")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func runShowVersion(_ context.Context, _ grpcapi.MaglevClient, _ []string) error {
|
|
fmt.Printf("maglevc %s (commit %s, built %s)\n",
|
|
buildinfo.Version(), buildinfo.Commit(), buildinfo.Date())
|
|
return nil
|
|
}
|
|
|
|
func runQuit(_ context.Context, _ grpcapi.MaglevClient, _ []string) error {
|
|
return errQuit
|
|
}
|
|
|
|
func runShowFrontends(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
resp, err := client.ListFrontends(ctx, &grpcapi.ListFrontendsRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, name := range resp.FrontendNames {
|
|
fmt.Println(name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func runShowFrontend(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: show frontend <name>")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.GetFrontend(ctx, &grpcapi.GetFrontendRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("name"), info.Name)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("address"), info.Address)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("protocol"), info.Protocol)
|
|
_, _ = fmt.Fprintf(w, "%s\t%d\n", label("port"), info.Port)
|
|
_, _ = fmt.Fprintf(w, "%s\t%t\n", label("src-ip-sticky"), info.SrcIpSticky)
|
|
_, _ = fmt.Fprintf(w, "%s\t%t\n", label("flush-on-down"), info.FlushOnDown)
|
|
if info.Description != "" {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("description"), info.Description)
|
|
}
|
|
if len(info.Pools) > 0 {
|
|
_, _ = fmt.Fprintf(w, "%s\n", label("pools"))
|
|
}
|
|
if err := w.Flush(); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Pool section uses direct Printf with fixed-width padding so that ANSI
|
|
// escape codes in labels don't confuse tabwriter's byte-based alignment.
|
|
// "backends" is always the widest pool label (8 chars); all pool labels
|
|
// are right-padded to that width, giving a 2+8+2 = 12-char visual indent.
|
|
const poolLblWidth = len("backends")
|
|
const poolIndent = " "
|
|
const poolSep = " "
|
|
contIndent := strings.Repeat(" ", len(poolIndent)+poolLblWidth+len(poolSep))
|
|
|
|
for _, pool := range info.Pools {
|
|
namePad := strings.Repeat(" ", poolLblWidth-len("name"))
|
|
fmt.Printf("%s%s%s%s%s\n", poolIndent, label("name"), namePad, poolSep, pool.Name)
|
|
for i, pb := range pool.Backends {
|
|
beInfo, beErr := client.GetBackend(ctx, &grpcapi.GetBackendRequest{Name: pb.Name})
|
|
suffix := ""
|
|
if beErr == nil && !beInfo.Enabled {
|
|
suffix = " [disabled]"
|
|
}
|
|
// Show both the configured weight (from YAML) and the
|
|
// state-aware effective weight (what gets programmed into VPP
|
|
// after pool-failover logic). Format matches the VPP-style
|
|
// key-value line so robot tests can parse it with a regex.
|
|
metaStr := fmt.Sprintf(" %s %d %s %d",
|
|
label("weight"), pb.Weight,
|
|
label("effective"), pb.EffectiveWeight)
|
|
if i == 0 {
|
|
bePad := strings.Repeat(" ", poolLblWidth-len("backends"))
|
|
fmt.Printf("%s%s%s%s%s%s%s\n", poolIndent, label("backends"), bePad, poolSep, pb.Name, metaStr, suffix)
|
|
} else {
|
|
fmt.Printf("%s%s%s%s\n", contIndent, pb.Name, metaStr, suffix)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func runShowBackends(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
resp, err := client.ListBackends(ctx, &grpcapi.ListBackendsRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, name := range resp.BackendNames {
|
|
fmt.Println(name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func runShowBackend(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: show backend <name>")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.GetBackend(ctx, &grpcapi.GetBackendRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("name"), info.Name)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("address"), info.Address)
|
|
stateDur := ""
|
|
if len(info.Transitions) > 0 {
|
|
since := time.Since(time.Unix(0, info.Transitions[0].AtUnixNs))
|
|
stateDur = " for " + formatDuration(since)
|
|
}
|
|
_, _ = fmt.Fprintf(w, "%s\t%s%s\n", label("state"), info.State, stateDur)
|
|
_, _ = fmt.Fprintf(w, "%s\t%v\n", label("enabled"), info.Enabled)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("healthcheck"), info.Healthcheck)
|
|
for i, t := range info.Transitions {
|
|
ts := time.Unix(0, t.AtUnixNs)
|
|
var lbl string
|
|
if i == 0 {
|
|
lbl = label("transitions")
|
|
} else {
|
|
// Pad to same visible width as "transitions" and wrap through
|
|
// label() so tabwriter sees the same byte count (ANSI overhead
|
|
// is identical on every row, keeping columns aligned).
|
|
lbl = label(" ")
|
|
}
|
|
_, _ = fmt.Fprintf(w, "%s\t%s → %s\t%s\t%s\n",
|
|
lbl,
|
|
t.From, t.To,
|
|
ts.Format("2006-01-02 15:04:05.000"),
|
|
formatAgo(time.Since(ts)),
|
|
)
|
|
}
|
|
return w.Flush()
|
|
}
|
|
|
|
func runShowHealthChecks(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
resp, err := client.ListHealthChecks(ctx, &grpcapi.ListHealthChecksRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, name := range resp.Names {
|
|
fmt.Println(name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func runShowHealthCheck(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: show healthcheck <name>")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.GetHealthCheck(ctx, &grpcapi.GetHealthCheckRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("name"), info.Name)
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("type"), info.Type)
|
|
if info.Port > 0 {
|
|
_, _ = fmt.Fprintf(w, "%s\t%d\n", label("port"), info.Port)
|
|
}
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("interval"), time.Duration(info.IntervalNs))
|
|
if info.FastIntervalNs > 0 {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("fast-interval"), time.Duration(info.FastIntervalNs))
|
|
}
|
|
if info.DownIntervalNs > 0 {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("down-interval"), time.Duration(info.DownIntervalNs))
|
|
}
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("timeout"), time.Duration(info.TimeoutNs))
|
|
_, _ = fmt.Fprintf(w, "%s\t%d\n", label("rise"), info.Rise)
|
|
_, _ = fmt.Fprintf(w, "%s\t%d\n", label("fall"), info.Fall)
|
|
if info.ProbeIpv4Src != "" {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("probe-ipv4-src"), info.ProbeIpv4Src)
|
|
}
|
|
if info.ProbeIpv6Src != "" {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("probe-ipv6-src"), info.ProbeIpv6Src)
|
|
}
|
|
if h := info.Http; h != nil {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("http.path"), h.Path)
|
|
if h.Host != "" {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("http.host"), h.Host)
|
|
}
|
|
_, _ = fmt.Fprintf(w, "%s\t%d-%d\n", label("http.response-code"), h.ResponseCodeMin, h.ResponseCodeMax)
|
|
if h.ResponseRegexp != "" {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("http.response-regexp"), h.ResponseRegexp)
|
|
}
|
|
}
|
|
if t := info.Tcp; t != nil {
|
|
_, _ = fmt.Fprintf(w, "%s\t%v\n", label("tcp.ssl"), t.Ssl)
|
|
if t.ServerName != "" {
|
|
_, _ = fmt.Fprintf(w, "%s\t%s\n", label("tcp.server-name"), t.ServerName)
|
|
}
|
|
}
|
|
return w.Flush()
|
|
}
|
|
|
|
func runPauseBackend(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: set backend <name> pause")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.PauseBackend(ctx, &grpcapi.BackendRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%s: setting state to '%s'\n", info.Name, info.State)
|
|
return nil
|
|
}
|
|
|
|
func runResumeBackend(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: set backend <name> resume")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.ResumeBackend(ctx, &grpcapi.BackendRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%s: setting state to '%s'\n", info.Name, info.State)
|
|
return nil
|
|
}
|
|
|
|
func runSetFrontendPoolBackendWeight(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
return setFrontendPoolBackendWeight(ctx, client, args, false)
|
|
}
|
|
|
|
func runSetFrontendPoolBackendWeightFlush(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
return setFrontendPoolBackendWeight(ctx, client, args, true)
|
|
}
|
|
|
|
func setFrontendPoolBackendWeight(ctx context.Context, client grpcapi.MaglevClient, args []string, flush bool) error {
|
|
if len(args) != 4 {
|
|
return fmt.Errorf("usage: set frontend <name> pool <pool> backend <name> weight <0-100> [flush]")
|
|
}
|
|
frontendName, poolName, backendName, weightStr := args[0], args[1], args[2], args[3]
|
|
weight, err := strconv.Atoi(weightStr)
|
|
if err != nil || weight < 0 || weight > 100 {
|
|
return fmt.Errorf("weight: expected integer 0-100, got %q", weightStr)
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.SetFrontendPoolBackendWeight(ctx, &grpcapi.SetWeightRequest{
|
|
Frontend: frontendName,
|
|
Pool: poolName,
|
|
Backend: backendName,
|
|
Weight: int32(weight),
|
|
Flush: flush,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Print the updated pool so the user can confirm the new weight.
|
|
for _, pool := range info.Pools {
|
|
if pool.Name != poolName {
|
|
continue
|
|
}
|
|
for _, pb := range pool.Backends {
|
|
if pb.Name == backendName {
|
|
flushNote := ""
|
|
if flush {
|
|
flushNote = " (flushed)"
|
|
}
|
|
fmt.Printf("%s pool %s backend %s: weight set to %d%s\n",
|
|
info.Name, pool.Name, pb.Name, pb.Weight, flushNote)
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func runEnableBackend(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: set backend <name> enable")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.EnableBackend(ctx, &grpcapi.BackendRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%s: enabled, state is '%s'\n", info.Name, info.State)
|
|
return nil
|
|
}
|
|
|
|
func runDisableBackend(ctx context.Context, client grpcapi.MaglevClient, args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("usage: set backend <name> disable")
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
info, err := client.DisableBackend(ctx, &grpcapi.BackendRequest{Name: args[0]})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%s: disabled, state is '%s'\n", info.Name, info.State)
|
|
return nil
|
|
}
|
|
|
|
func runConfigCheck(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
resp, err := client.CheckConfig(ctx, &grpcapi.CheckConfigRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if resp.Ok {
|
|
fmt.Println("config ok")
|
|
return nil
|
|
}
|
|
if resp.ParseError != "" {
|
|
return fmt.Errorf("parse error: %s", resp.ParseError)
|
|
}
|
|
return fmt.Errorf("semantic error: %s", resp.SemanticError)
|
|
}
|
|
|
|
func runConfigReload(ctx context.Context, client grpcapi.MaglevClient, _ []string) error {
|
|
ctx, cancel := context.WithTimeout(ctx, callTimeout)
|
|
defer cancel()
|
|
resp, err := client.ReloadConfig(ctx, &grpcapi.ReloadConfigRequest{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if resp.Ok {
|
|
fmt.Println("config reloaded")
|
|
return nil
|
|
}
|
|
if resp.ParseError != "" {
|
|
return fmt.Errorf("parse error: %s", resp.ParseError)
|
|
}
|
|
if resp.SemanticError != "" {
|
|
return fmt.Errorf("semantic error: %s", resp.SemanticError)
|
|
}
|
|
return fmt.Errorf("reload error: %s", resp.ReloadError)
|
|
}
|
|
|
|
// formatDuration formats a duration as Xd Xh Xm Xs without milliseconds.
|
|
func formatDuration(d time.Duration) string {
|
|
if d < 0 {
|
|
d = 0
|
|
}
|
|
d = d.Truncate(time.Second)
|
|
|
|
days := int(d.Hours()) / 24
|
|
d -= time.Duration(days) * 24 * time.Hour
|
|
hours := int(d.Hours())
|
|
d -= time.Duration(hours) * time.Hour
|
|
minutes := int(d.Minutes())
|
|
d -= time.Duration(minutes) * time.Minute
|
|
seconds := int(d.Seconds())
|
|
|
|
var b strings.Builder
|
|
if days > 0 {
|
|
fmt.Fprintf(&b, "%dd", days)
|
|
}
|
|
if hours > 0 {
|
|
fmt.Fprintf(&b, "%dh", hours)
|
|
}
|
|
if minutes > 0 {
|
|
fmt.Fprintf(&b, "%dm", minutes)
|
|
}
|
|
if seconds > 0 || b.Len() == 0 {
|
|
fmt.Fprintf(&b, "%ds", seconds)
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
func formatAgo(d time.Duration) string {
|
|
return formatDuration(d) + " ago"
|
|
}
|