Jon Chery
790109ea24
- node capacity set: partial updates (only set dimensions passed; read-modify-write on existing row) - node capacity auto [percentage]: SSH to node, discover CPU (nproc), memory (/proc/meminfo), disk (df), multiply by percentage (default 75) - ACL check --verbose: prints resolved ACLPath + all entries + identity - job list UX: short 8-char IDs, NODE column, conditional EXIT (- for non-terminal statuses) ---ci--- project: orca milestone: v0.12.18 phase: D status: complete requirements: covered: [168, 169] ---/ci---
260 lines
8.2 KiB
Go
260 lines
8.2 KiB
Go
// node_capacity.go implements `orca node capacity` for v0.2 P02.
|
|
// The capacity declaration is per-node (cpu_millicores, memory_mib,
|
|
// disk_mib) and feeds the bin-packing scheduler.
|
|
//
|
|
// REQ-028: HCL/YAML schema for NodeCapacity — the CLI accepts the
|
|
// three numeric flags and writes a row to the `node_capacity` table.
|
|
// A future enhancement can read `~/.orca/node.hcl` at join time
|
|
// (out of scope for P02).
|
|
package cli
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"git.cloudinit.dev/coreci/orca/internal/certpaths"
|
|
"git.cloudinit.dev/coreci/orca/internal/sshpush"
|
|
"git.cloudinit.dev/coreci/orca/internal/store"
|
|
)
|
|
|
|
var (
|
|
capSetCPU int64
|
|
capSetMem int64
|
|
capSetDisk int64
|
|
capNodeID string
|
|
)
|
|
|
|
var nodeCapacityCmd = &cobra.Command{
|
|
Use: "capacity",
|
|
Short: "Manage node capacity declarations (P02 bin-packing input)",
|
|
Long: "Read or write the per-node capacity used by the multi-node scheduler.",
|
|
}
|
|
|
|
var nodeCapacityShowCmd = &cobra.Command{
|
|
Use: "show [node-id]",
|
|
Short: "Show capacity for a node (defaults to 'self')",
|
|
Args: cobra.MaximumNArgs(1),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
id := capNodeID
|
|
if id == "" && len(args) > 0 {
|
|
id = args[0]
|
|
}
|
|
if id == "" {
|
|
id = "self"
|
|
}
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 5*time.Second)
|
|
defer cancel()
|
|
db, closer, err := openDB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closer()
|
|
repo := store.NewCapacityRepo(db)
|
|
c, err := repo.Get(ctx, id)
|
|
if err != nil {
|
|
return fmt.Errorf("node %s: %w (use `orca node capacity --set` to declare)", id, err)
|
|
}
|
|
if jsonOutput {
|
|
return printJSON(c)
|
|
}
|
|
fmt.Fprintf(cmd.OutOrStdout(), "Node: %s\n", c.NodeID)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "CPU: %d millicores\n", c.CPUMillicores)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "Memory: %d MiB\n", c.MemoryMiB)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "Disk: %d MiB\n", c.DiskMiB)
|
|
fmt.Fprintf(cmd.OutOrStdout(), "Updated: %s\n", c.UpdatedAt.UTC().Format(time.RFC3339))
|
|
return nil
|
|
},
|
|
}
|
|
|
|
var nodeCapacitySetCmd = &cobra.Command{
|
|
Use: "set",
|
|
Short: "Declare capacity for a node (used by bin-packing)",
|
|
Long: "Write cpu_millicores, memory_mib, and disk_mib for the named node. Idempotent: subsequent calls overwrite.",
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
// REQ-168: allow partial updates. At least one dimension
|
|
// must be positive; the others are read from the existing
|
|
// row (or default to 0 if no row exists yet).
|
|
if capSetCPU <= 0 && capSetMem <= 0 && capSetDisk <= 0 {
|
|
return fmt.Errorf("at least one of --cpu, --memory, or --disk must be positive")
|
|
}
|
|
id := capNodeID
|
|
if id == "" {
|
|
id = "self"
|
|
}
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 5*time.Second)
|
|
defer cancel()
|
|
db, closer, err := openDB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closer()
|
|
repo := store.NewCapacityRepo(db)
|
|
// Read existing row for partial update.
|
|
existing, _ := repo.Get(ctx, id)
|
|
cpu := capSetCPU
|
|
mem := capSetMem
|
|
disk := capSetDisk
|
|
if existing != nil {
|
|
if cpu <= 0 {
|
|
cpu = existing.CPUMillicores
|
|
}
|
|
if mem <= 0 {
|
|
mem = existing.MemoryMiB
|
|
}
|
|
if disk <= 0 {
|
|
disk = existing.DiskMiB
|
|
}
|
|
}
|
|
c := &store.NodeCapacity{
|
|
NodeID: id,
|
|
CPUMillicores: cpu,
|
|
MemoryMiB: mem,
|
|
DiskMiB: disk,
|
|
}
|
|
if err := repo.Upsert(ctx, c); err != nil {
|
|
return err
|
|
}
|
|
if jsonOutput {
|
|
return printJSON(c)
|
|
}
|
|
fmt.Fprintf(cmd.OutOrStdout(), "✓ Capacity set for %s: cpu=%d mem=%d disk=%d\n",
|
|
c.NodeID, c.CPUMillicores, c.MemoryMiB, c.DiskMiB)
|
|
return nil
|
|
},
|
|
}
|
|
|
|
var nodeCapacityListCmd = &cobra.Command{
|
|
Use: "list",
|
|
Short: "List all node capacity declarations",
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 5*time.Second)
|
|
defer cancel()
|
|
db, closer, err := openDB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closer()
|
|
repo := store.NewCapacityRepo(db)
|
|
rows, err := repo.List(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if jsonOutput {
|
|
return printJSON(rows)
|
|
}
|
|
if len(rows) == 0 {
|
|
fmt.Fprintln(cmd.OutOrStdout(), "No capacity declarations. Use `orca node capacity --set` to add one.")
|
|
return nil
|
|
}
|
|
fmt.Fprintf(cmd.OutOrStdout(), "%-20s %12s %12s %12s %s\n", "NODE", "CPU(mc)", "MEM(MiB)", "DISK(MiB)", "UPDATED")
|
|
for _, c := range rows {
|
|
fmt.Fprintf(cmd.OutOrStdout(), "%-20s %12d %12d %12d %s\n",
|
|
c.NodeID, c.CPUMillicores, c.MemoryMiB, c.DiskMiB, c.UpdatedAt.UTC().Format(time.RFC3339))
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
|
|
|
|
// nodeCapacityAutoCmd discovers capacity by SSHing to the node and
|
|
// reading nproc, /proc/meminfo, df (REQ-168, Phase D2).
|
|
var capAutoPct int
|
|
|
|
var nodeCapacityAutoCmd = &cobra.Command{
|
|
Use: "auto [percentage]",
|
|
Short: "Auto-discover node capacity via SSH (default 75% of physical)",
|
|
Long: `SSH to the specified node and discover CPU cores, memory,
|
|
and disk capacity. Multiplies the physical values by the given
|
|
percentage (default 75) to reserve headroom for the OS. The discovered
|
|
values are written to the capacity table (same as 'orca node capacity set').`,
|
|
Args: cobra.MaximumNArgs(1),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
pct := 75
|
|
if len(args) > 0 {
|
|
var err error
|
|
pct, err = strconv.Atoi(args[0])
|
|
if err != nil || pct < 1 || pct > 100 {
|
|
return fmt.Errorf("percentage must be 1-100, got %q", args[0])
|
|
}
|
|
}
|
|
id := capNodeID
|
|
if id == "" {
|
|
return fmt.Errorf("--node is required for capacity auto")
|
|
}
|
|
// Build SSH transport and exec discovery commands.
|
|
transport := sshpush.NewTransport(certpaths.SSHKeyPath(), certpaths.KnownHostsPath())
|
|
defer transport.Close()
|
|
ctx, cancel := context.WithTimeout(cmd.Context(), 30*time.Second)
|
|
defer cancel()
|
|
// CPU: nproc
|
|
cpuOut, err := transport.Exec(ctx, id, "nproc")
|
|
if err != nil {
|
|
return fmt.Errorf("capacity auto: SSH exec nproc on %s: %w", id, err)
|
|
}
|
|
cores, err := strconv.Atoi(strings.TrimSpace(string(cpuOut)))
|
|
if err != nil {
|
|
return fmt.Errorf("capacity auto: parse nproc output %q: %w", string(cpuOut), err)
|
|
}
|
|
// Memory: MemTotal from /proc/meminfo (in kB -> MiB)
|
|
memOut, err := transport.Exec(ctx, id, "awk '/MemTotal/{print $2}' /proc/meminfo")
|
|
if err != nil {
|
|
return fmt.Errorf("capacity auto: SSH exec meminfo on %s: %w", id, err)
|
|
}
|
|
memKB, err := strconv.ParseInt(strings.TrimSpace(string(memOut)), 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("capacity auto: parse meminfo output %q: %w", string(memOut), err)
|
|
}
|
|
// Disk: df on root (1K-blocks -> MiB)
|
|
diskOut, err := transport.Exec(ctx, id, "df --output=size / | tail -1")
|
|
if err != nil {
|
|
return fmt.Errorf("capacity auto: SSH exec df on %s: %w", id, err)
|
|
}
|
|
diskKB, err := strconv.ParseInt(strings.TrimSpace(string(diskOut)), 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("capacity auto: parse df output %q: %w", string(diskOut), err)
|
|
}
|
|
// Apply percentage, convert to millicores/MiB.
|
|
cpuM := int64(cores) * 1000 * int64(pct) / 100
|
|
memMib := memKB * int64(pct) / 100 / 1024
|
|
diskMib := diskKB * int64(pct) / 100 / 1024
|
|
// Write to DB.
|
|
db, closer, err := openDB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closer()
|
|
repo := store.NewCapacityRepo(db)
|
|
c := &store.NodeCapacity{
|
|
NodeID: id,
|
|
CPUMillicores: cpuM,
|
|
MemoryMiB: memMib,
|
|
DiskMiB: diskMib,
|
|
}
|
|
if err := repo.Upsert(ctx, c); err != nil {
|
|
return err
|
|
}
|
|
if jsonOutput {
|
|
return printJSON(c)
|
|
}
|
|
fmt.Fprintf(cmd.OutOrStdout(), "Capacity auto-discovered for %s (%d%%): cpu=%dm, mem=%dMiB, disk=%dMiB\n", id, pct, cpuM, memMib, diskMib)
|
|
return nil
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
nodeCapacitySetCmd.Flags().Int64Var(&capSetCPU, "cpu", 0, "CPU capacity in millicores (1000 = 1 vCPU)")
|
|
nodeCapacitySetCmd.Flags().Int64Var(&capSetMem, "memory", 0, "Memory capacity in MiB")
|
|
nodeCapacitySetCmd.Flags().Int64Var(&capSetDisk, "disk", 0, "Disk capacity in MiB")
|
|
nodeCapacitySetCmd.Flags().StringVar(&capNodeID, "node", "", "node id (defaults to 'self')")
|
|
nodeCapacityShowCmd.Flags().StringVar(&capNodeID, "node", "", "node id (defaults to 'self')")
|
|
|
|
nodeCapacityAutoCmd.Flags().StringVar(&capNodeID, "node", "", "node name or ID to auto-discover capacity for")
|
|
nodeCapacityCmd.AddCommand(nodeCapacityShowCmd, nodeCapacitySetCmd, nodeCapacityListCmd, nodeCapacityAutoCmd)
|
|
nodeCmd.AddCommand(nodeCapacityCmd)
|
|
}
|