From a4ba815113f30475545a94b91aba69e0ebd05dd2 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 1 Jul 2026 12:46:17 +0200 Subject: [PATCH 01/32] Refresh the status of the instance owning a changed ip addr Now that the daemon bus routes NetIPAddrDeleted and NetIPAddrAdded events (sent by netmon on netlink events), make imon trigger a instance status refresh if the instance has the ipaddr in one of its resource info. --- daemon/imon/main.go | 6 ++++ daemon/imon/main_cmd.go | 72 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/daemon/imon/main.go b/daemon/imon/main.go index a5c37ee44..c45f3be0d 100644 --- a/daemon/imon/main.go +++ b/daemon/imon/main.go @@ -311,6 +311,8 @@ func (t *Manager) startSubscriptions(qs pubsub.QueueSizer) { sub.AddFilter(&msgbus.ObjectStatusUpdated{}, t.labelPath) sub.AddFilter(&msgbus.ProgressInstanceMonitor{}, t.labelPath) sub.AddFilter(&msgbus.SetInstanceMonitor{}, t.labelPath) + sub.AddFilter(&msgbus.NetIPAddrAdded{}, t.labelLocalhost) + sub.AddFilter(&msgbus.NetIPAddrDeleted{}, t.labelLocalhost) sub.Start() t.sub = sub } @@ -453,6 +455,10 @@ func (t *Manager) worker(initialNodes []string) { t.onNodeStatusUpdated(c) case *msgbus.NodeStatsUpdated: t.onNodeStatsUpdated(c) + case *msgbus.NetIPAddrAdded: + t.onNetIPAddrAdded(c) + case *msgbus.NetIPAddrDeleted: + t.onNetIPAddrDeleted(c) } case i := <-t.cmdC: if t.ctx.Err() != nil { diff --git a/daemon/imon/main_cmd.go b/daemon/imon/main_cmd.go index aad7b7b61..a12829e1a 100644 --- a/daemon/imon/main_cmd.go +++ b/daemon/imon/main_cmd.go @@ -5,6 +5,7 @@ import ( "crypto/md5" "errors" "fmt" + "net" "slices" "sort" "strings" @@ -1283,3 +1284,74 @@ func (t *Manager) savePendingOrchestration() { t.orchestrationPending = nil } } + +// extractIP extracts just the IP address from various formats (CIDR, with port, plain IP) +func extractIP(addr string) string { + if host, _, err := net.SplitHostPort(addr); err == nil { + return host + } + if ip, _, err := net.ParseCIDR(addr); err == nil { + return ip.String() + } + return addr +} + +// checkResourceForIPMatch checks if any resource has a matching IP address and triggers status refresh if found +func (t *Manager) checkResourceForIPMatch(ip string, linkName string, eventType string) { + // Get local instance status + instStatus, ok := t.instStatus[t.localhost] + if !ok { + t.log.Tracef("no local instance status found for IP address %s event", eventType) + return + } + + // Check if any resource has a matching IP address + for rid, rstat := range instStatus.Resources { + if ipaddr, ok := rstat.Info["ipaddr"]; ok { + // ipaddr can be a string or net.IP, convert to string for comparison + var ipaddrStr string + switch v := ipaddr.(type) { + case string: + ipaddrStr = v + case net.IP: + ipaddrStr = v.String() + default: + ipaddrStr = fmt.Sprintf("%v", v) + } + + if ipaddrStr == ip { + t.log.Infof("IP address %s on link %s, matching resource %s - triggering status refresh", ip, linkName, rid) + t.requestStatusRefresh(t.instConfig.Priority) + return + } + } + } + + t.log.Tracef("no resource found with IP address %s on link %s", ip, linkName) +} + +// onNetIPAddrAdded is called when a network IP address is added to a link. +// It checks if any instance resource has a matching IP address in its info, +// and if so, triggers a status refresh to update the resource status. +func (t *Manager) onNetIPAddrAdded(c *msgbus.NetIPAddrAdded) { + // Only handle events for the localhost + if c.Node != t.localhost { + return + } + + ip := extractIP(c.Address) + t.checkResourceForIPMatch(ip, c.LinkName, "added") +} + +// onNetIPAddrDeleted is called when a network IP address is deleted from a link. +// It checks if any instance resource has a matching IP address in its info, +// and if so, triggers a status refresh to update the resource status. +func (t *Manager) onNetIPAddrDeleted(c *msgbus.NetIPAddrDeleted) { + // Only handle events for the localhost + if c.Node != t.localhost { + return + } + + ip := extractIP(c.Address) + t.checkResourceForIPMatch(ip, c.LinkName, "deleted") +} From 84dcc1c5642f61b541efc2f8cca7a988660278fc Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 1 Jul 2026 18:47:44 +0200 Subject: [PATCH 02/32] Add a mntmon daemon manager To relay mount/umount/remount events on the daemon bus. --- daemon/daemon/main.go | 2 + daemon/mntmon/main.go | 267 ++++++++++++++++++++++++++++++++++++++ daemon/msgbus/messages.go | 58 +++++++++ 3 files changed, 327 insertions(+) create mode 100644 daemon/mntmon/main.go diff --git a/daemon/daemon/main.go b/daemon/daemon/main.go index 7fd0beeb4..6643e1e1b 100644 --- a/daemon/daemon/main.go +++ b/daemon/daemon/main.go @@ -38,6 +38,7 @@ import ( "github.com/opensvc/om3/v3/daemon/hook" "github.com/opensvc/om3/v3/daemon/imon" "github.com/opensvc/om3/v3/daemon/istat" + "github.com/opensvc/om3/v3/daemon/mntmon" "github.com/opensvc/om3/v3/daemon/listener" "github.com/opensvc/om3/v3/daemon/msgbus" "github.com/opensvc/om3/v3/daemon/netmon" @@ -244,6 +245,7 @@ func (t *T) Start(ctx context.Context) error { listener.New(), nmon.NewManager(daemonenv.DrainChanDuration, qsMedium), netmon.NewManager(daemonenv.DrainChanDuration, qsSmall), + mntmon.NewManager(daemonenv.DrainChanDuration, qsSmall), hook.NewManager(daemonenv.DrainChanDuration, qsSmall), dns.NewManager(daemonenv.DrainChanDuration, qsMedium), pgmetrics.New(qsMedium), diff --git a/daemon/mntmon/main.go b/daemon/mntmon/main.go new file mode 100644 index 000000000..ce888e071 --- /dev/null +++ b/daemon/mntmon/main.go @@ -0,0 +1,267 @@ +// Package mntmon is responsible for monitoring filesystem mount/umount/remount events +// and publishing them as pubsub events. +// +// It watches /proc/self/mountinfo for changes via the kernel's POLLPRI/POLLERR wakeup mechanism. +package mntmon + +import ( + "bufio" + "context" + "os" + "strings" + "sync" + "time" + + "github.com/opensvc/om3/v3/daemon/msgbus" + "github.com/opensvc/om3/v3/util/hostname" + "github.com/opensvc/om3/v3/util/plog" + "github.com/opensvc/om3/v3/util/pubsub" + "golang.org/x/sys/unix" +) + +// mountEntry is a minimal parse of a /proc/*/mountinfo line, keyed by +// mount ID so remounts of the same path are still distinguishable. +type mountEntry struct { + id, mountPoint, fsType, source, options string +} + +func parseMountinfo(path string) (map[string]mountEntry, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + + entries := make(map[string]mountEntry) + sc := bufio.NewScanner(f) + for sc.Scan() { + fields := strings.Fields(sc.Text()) + if len(fields) < 10 { + continue + } + // Fields: id parent major:minor root mountpoint opts ... - fstype source ... + sepIdx := -1 + for i, fld := range fields { + if fld == "-" { + sepIdx = i + break + } + } + if sepIdx == -1 || sepIdx+2 >= len(fields) { + continue + } + // fields[5] = per-mount options (e.g. "rw,relatime") + // fields[sepIdx+3], if present = super options (e.g. "rw,errors=remount-ro") + superOpts := "" + if sepIdx+3 < len(fields) { + superOpts = fields[sepIdx+3] + } + e := mountEntry{ + id: fields[0], + mountPoint: fields[4], + fsType: fields[sepIdx+1], + source: fields[sepIdx+2], + options: fields[5] + "|" + superOpts, + } + entries[e.id] = e + } + return entries, sc.Err() +} + +type ( + // Manager monitors mount/umount events and publishes them to the message bus + Manager struct { + drainDuration time.Duration + + ctx context.Context + cancel context.CancelFunc + log *plog.Logger + + publisher pubsub.Publisher + databus interface{} + sub *pubsub.Subscription + subQS pubsub.QueueSizer + + localhost string + labelLocalhost pubsub.Label + + wg sync.WaitGroup + } +) + +// NewManager creates a new mount monitor manager +func NewManager(drainDuration time.Duration, subQS pubsub.QueueSizer) *Manager { + localhost := hostname.Hostname() + return &Manager{ + drainDuration: drainDuration, + log: plog.NewDefaultLogger().Attr("pkg", "daemon/mntmon").WithPrefix("daemon: mntmon: "), + localhost: localhost, + labelLocalhost: pubsub.Label{"node", localhost}, + subQS: subQS, + } +} + +// Start launches the mntmon worker goroutine +func (t *Manager) Start(parent context.Context) error { + t.log.Infof("starting") + t.ctx, t.cancel = context.WithCancel(parent) + t.publisher = pubsub.PubFromContext(t.ctx) + + // Start pubsub subscriptions for audit and other control messages + t.startSubscriptions() + + t.wg.Add(1) + go func() { + defer t.wg.Done() + defer t.log.Infof("mount monitor done") + t.watchMounts() + }() + + t.log.Infof("started") + return nil +} + +// Stop stops the mntmon manager +func (t *Manager) Stop() error { + t.log.Infof("stopping") + defer t.log.Infof("stopped") + t.cancel() + if t.sub != nil { + if err := t.sub.Stop(); err != nil { + t.log.Warnf("subscription stop: %s", err) + } + } + t.wg.Wait() + return nil +} + +// startSubscriptions starts the pubsub subscriptions for control messages like AuditStart/AuditStop +func (t *Manager) startSubscriptions() { + sub := pubsub.SubFromContext(t.ctx, "daemon.mntmon", t.subQS) + + sub.AddFilter(&msgbus.AuditStart{}) + sub.AddFilter(&msgbus.AuditStop{}) + + sub.Start() + t.sub = sub + + t.wg.Add(1) + go func() { + defer t.wg.Done() + for { + select { + case <-t.ctx.Done(): + return + case ev := <-sub.C: + switch c := ev.(type) { + case *msgbus.AuditStart: + t.log.HandleAuditStart(c.Q, c.Subsystems, "mntmon") + case *msgbus.AuditStop: + t.log.HandleAuditStop(c.Q, c.Subsystems, "mntmon") + } + } + } + }() +} + +// watchMounts watches /proc/self/mountinfo for changes and emits msgbus events +func (t *Manager) watchMounts() { + t.log.Infof("starting mount monitor") + + mountinfoPath := "/proc/self/mountinfo" + + fd, err := unix.Open(mountinfoPath, unix.O_RDONLY, 0) + if err != nil { + t.log.Errorf("open %s: %s", mountinfoPath, err) + return + } + defer unix.Close(fd) + + prev, err := parseMountinfo(mountinfoPath) + if err != nil { + t.log.Errorf("parse mountinfo: %s", err) + return + } + + pfd := []unix.PollFd{{Fd: int32(fd), Events: unix.POLLERR | unix.POLLPRI}} + + // Use a finite poll timeout to allow checking context cancellation + const pollTimeout = 300 * time.Millisecond + + for { + select { + case <-t.ctx.Done(): + t.log.Infof("context done, stopping mount monitor") + return + default: + } + + // Poll with finite timeout + _, err := unix.Poll(pfd, int(pollTimeout.Milliseconds())) + if err != nil { + if err == unix.EINTR { + continue + } + t.log.Errorf("poll: %s", err) + return + } + + // Check context after poll returns (either due to event or timeout) + select { + case <-t.ctx.Done(): + t.log.Infof("context done, stopping mount monitor") + return + default: + } + + cur, err := parseMountinfo(mountinfoPath) + if err != nil { + t.log.Errorf("parse mountinfo: %s", err) + continue + } + + // Publish mount and remount events + for id, e := range cur { + old, existed := prev[id] + switch { + case !existed: + msg := &msgbus.FSMounted{ + Node: t.localhost, + MountPoint: e.mountPoint, + FSType: e.fsType, + Source: e.source, + Options: e.options, + } + t.log.Infof("filesystem mounted: %s (type=%s, source=%s)", e.mountPoint, e.fsType, e.source) + t.publisher.Pub(msg, t.labelLocalhost) + case old.options != e.options: + msg := &msgbus.FSRemounted{ + Node: t.localhost, + MountPoint: e.mountPoint, + FSType: e.fsType, + Source: e.source, + Options: e.options, + } + t.log.Infof("filesystem remounted: %s (type=%s, source=%s)", e.mountPoint, e.fsType, e.source) + t.publisher.Pub(msg, t.labelLocalhost) + } + } + + // Publish umount events + for id, e := range prev { + if _, ok := cur[id]; !ok { + msg := &msgbus.FSUmounted{ + Node: t.localhost, + MountPoint: e.mountPoint, + FSType: e.fsType, + Source: e.source, + Options: e.options, + } + t.log.Infof("filesystem unmounted: %s (type=%s, source=%s)", e.mountPoint, e.fsType, e.source) + t.publisher.Pub(msg, t.labelLocalhost) + } + } + + prev = cur + } +} diff --git a/daemon/msgbus/messages.go b/daemon/msgbus/messages.go index 402529daa..d6a9bce2a 100644 --- a/daemon/msgbus/messages.go +++ b/daemon/msgbus/messages.go @@ -273,6 +273,10 @@ var ( "NetLinkUp": func() any { return &NetLinkUp{} }, "NetIPAddrAdded": func() any { return &NetIPAddrAdded{} }, "NetIPAddrDeleted": func() any { return &NetIPAddrDeleted{} }, + + "FSMounted": func() any { return &FSMounted{} }, + "FSUmounted": func() any { return &FSUmounted{} }, + "FSRemounted": func() any { return &FSRemounted{} }, } ) @@ -1013,6 +1017,36 @@ type ( LinkName string `json:"link_name" yaml:"link_name"` Address string `json:"address" yaml:"address"` } + + // FSMounted is published when a filesystem is mounted + FSMounted struct { + pubsub.Msg `yaml:",inline"` + Node string `json:"node" yaml:"node"` + MountPoint string `json:"mount_point" yaml:"mount_point"` + FSType string `json:"fs_type" yaml:"fs_type"` + Source string `json:"source" yaml:"source"` + Options string `json:"options" yaml:"options"` + } + + // FSUmounted is published when a filesystem is unmounted + FSUmounted struct { + pubsub.Msg `yaml:",inline"` + Node string `json:"node" yaml:"node"` + MountPoint string `json:"mount_point" yaml:"mount_point"` + FSType string `json:"fs_type" yaml:"fs_type"` + Source string `json:"source" yaml:"source"` + Options string `json:"options" yaml:"options"` + } + + // FSRemounted is published when a filesystem is remounted + FSRemounted struct { + pubsub.Msg `yaml:",inline"` + Node string `json:"node" yaml:"node"` + MountPoint string `json:"mount_point" yaml:"mount_point"` + FSType string `json:"fs_type" yaml:"fs_type"` + Source string `json:"source" yaml:"source"` + Options string `json:"options" yaml:"options"` + } ) func DropPendingMsg(c <-chan any, duration time.Duration) { @@ -1564,6 +1598,30 @@ func (e *NetIPAddrDeleted) Key() string { return fmt.Sprintf("NetIPAddrDeleted,node=%s,link_name=%s,address=%s", e.Node, e.LinkName, e.Address) } +func (e *FSMounted) Kind() string { + return "FSMounted" +} + +func (e *FSMounted) Key() string { + return fmt.Sprintf("FSMounted,node=%s,mount_point=%s", e.Node, e.MountPoint) +} + +func (e *FSUmounted) Kind() string { + return "FSUmounted" +} + +func (e *FSUmounted) Key() string { + return fmt.Sprintf("FSUmounted,node=%s,mount_point=%s", e.Node, e.MountPoint) +} + +func (e *FSRemounted) Kind() string { + return "FSRemounted" +} + +func (e *FSRemounted) Key() string { + return fmt.Sprintf("FSRemounted,node=%s,mount_point=%s", e.Node, e.MountPoint) +} + func NewSetInstanceMonitorWithErr(ctx context.Context, p naming.Path, nodename string, value instance.MonitorUpdate) (*SetInstanceMonitor, errcontext.ErrReceiver) { err := errcontext.New(ctx) return &SetInstanceMonitor{Path: p, Node: nodename, Value: value, Err: err}, err From 6d0c8c3879b896a18ed08fb73b6da26e760f350b Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 1 Jul 2026 19:17:44 +0200 Subject: [PATCH 03/32] Queue a instance status refresh if one of its mounts changed Subscribe imon to FS* events, add a "mnt" (and "dev" for future use) resource status info in a drivers handling mounts, lookup the changed mount in the instance status infos, on match queue status refresh. --- daemon/imon/main.go | 9 ++++++ daemon/imon/main_cmd.go | 65 +++++++++++++++++++++++++++++++++++++++ drivers/resfshost/main.go | 7 +++++ drivers/resfszfs/main.go | 7 +++++ 4 files changed, 88 insertions(+) diff --git a/daemon/imon/main.go b/daemon/imon/main.go index c45f3be0d..06f66b18f 100644 --- a/daemon/imon/main.go +++ b/daemon/imon/main.go @@ -313,6 +313,9 @@ func (t *Manager) startSubscriptions(qs pubsub.QueueSizer) { sub.AddFilter(&msgbus.SetInstanceMonitor{}, t.labelPath) sub.AddFilter(&msgbus.NetIPAddrAdded{}, t.labelLocalhost) sub.AddFilter(&msgbus.NetIPAddrDeleted{}, t.labelLocalhost) + sub.AddFilter(&msgbus.FSMounted{}, t.labelLocalhost) + sub.AddFilter(&msgbus.FSUmounted{}, t.labelLocalhost) + sub.AddFilter(&msgbus.FSRemounted{}, t.labelLocalhost) sub.Start() t.sub = sub } @@ -459,6 +462,12 @@ func (t *Manager) worker(initialNodes []string) { t.onNetIPAddrAdded(c) case *msgbus.NetIPAddrDeleted: t.onNetIPAddrDeleted(c) + case *msgbus.FSMounted: + t.onFSMounted(c) + case *msgbus.FSUmounted: + t.onFSUmounted(c) + case *msgbus.FSRemounted: + t.onFSRemounted(c) } case i := <-t.cmdC: if t.ctx.Err() != nil { diff --git a/daemon/imon/main_cmd.go b/daemon/imon/main_cmd.go index a12829e1a..571ab4aef 100644 --- a/daemon/imon/main_cmd.go +++ b/daemon/imon/main_cmd.go @@ -1355,3 +1355,68 @@ func (t *Manager) onNetIPAddrDeleted(c *msgbus.NetIPAddrDeleted) { ip := extractIP(c.Address) t.checkResourceForIPMatch(ip, c.LinkName, "deleted") } + +// checkResourceForMountMatch checks if any resource has a matching mount point +func (t *Manager) checkResourceForMountMatch(mountPoint string, fsType string, eventType string) { + // Get local instance status + instStatus, ok := t.instStatus[t.localhost] + if !ok { + t.log.Tracef("no local instance status found for filesystem %s event", eventType) + return + } + + // Check if any resource has a matching mount point + for rid, rstat := range instStatus.Resources { + if mnt, ok := rstat.Info["mnt"]; ok { + // mnt can be a string, convert to string for comparison + var mntStr string + switch v := mnt.(type) { + case string: + mntStr = v + default: + mntStr = fmt.Sprintf("%v", v) + } + + if mntStr == mountPoint { + t.log.Infof("filesystem %s event on mount point %s, matching resource %s - triggering status refresh", eventType, mountPoint, rid) + t.requestStatusRefresh(t.instConfig.Priority) + return + } + } + } + + t.log.Tracef("no resource found with mount point %s", mountPoint) +} + +// onFSMounted is called when a filesystem is mounted. +// It checks if any instance resource has a matching mount point in its info, +// and if so, triggers a status refresh to update the resource status. +func (t *Manager) onFSMounted(c *msgbus.FSMounted) { + // Only handle events for the localhost + if c.Node != t.localhost { + return + } + t.checkResourceForMountMatch(c.MountPoint, c.FSType, "mounted") +} + +// onFSUmounted is called when a filesystem is unmounted. +// It checks if any instance resource has a matching mount point in its info, +// and if so, triggers a status refresh to update the resource status. +func (t *Manager) onFSUmounted(c *msgbus.FSUmounted) { + // Only handle events for the localhost + if c.Node != t.localhost { + return + } + t.checkResourceForMountMatch(c.MountPoint, c.FSType, "unmounted") +} + +// onFSRemounted is called when a filesystem is remounted. +// It checks if any instance resource has a matching mount point in its info, +// and if so, triggers a status refresh to update the resource status. +func (t *Manager) onFSRemounted(c *msgbus.FSRemounted) { + // Only handle events for the localhost + if c.Node != t.localhost { + return + } + t.checkResourceForMountMatch(c.MountPoint, c.FSType, "remounted") +} diff --git a/drivers/resfshost/main.go b/drivers/resfshost/main.go index 58b21fe65..b09daac33 100644 --- a/drivers/resfshost/main.go +++ b/drivers/resfshost/main.go @@ -199,6 +199,13 @@ func (t *T) Info(ctx context.Context) (resource.InfoKeys, error) { return m, nil } +// StatusInfo implements resource.StatusInfoer +func (t *T) StatusInfo(ctx context.Context) map[string]interface{} { + data := make(map[string]interface{}) + data["mnt"] = t.mountPoint() + return data +} + func (t *T) testFile() string { return filepath.Join(t.mountPoint(), ".opensvc") } diff --git a/drivers/resfszfs/main.go b/drivers/resfszfs/main.go index bf6695e2e..254f860d7 100644 --- a/drivers/resfszfs/main.go +++ b/drivers/resfszfs/main.go @@ -139,6 +139,13 @@ func (t *T) Info(ctx context.Context) (resource.InfoKeys, error) { return m, nil } +// StatusInfo implements resource.StatusInfoer +func (t *T) StatusInfo(ctx context.Context) map[string]interface{} { + data := make(map[string]interface{}) + data["mnt"] = t.mountPoint() + return data +} + func (t *T) testFile() string { return filepath.Join(t.mountPoint(), ".opensvc") } From ccd99d29e6e8bdf16f32d1d69577a70c2419eea5 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Thu, 2 Jul 2026 09:57:08 +0200 Subject: [PATCH 04/32] Update the README --- README.md | 47 ++++++++++++++++++++++++++--------------------- 1 file changed, 26 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index c8213f742..53adaadd0 100644 --- a/README.md +++ b/README.md @@ -1,31 +1,36 @@ -# README.md +# om3 [![Go](https://github.com/opensvc/om3/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/opensvc/om3/actions/workflows/go.yml) -**_NOTE:_** This project is the golang port and next release of https://github.com/opensvc/opensvc. +*The Go port and continuation of [opensvc/opensvc](https://github.com/opensvc/opensvc).* -> **_NOTE:_** General Availability is expected Q1 2025 +om3 is a cluster orchestrator for small-to-mid clusters — a coherent alternative to +stitching together systemd, container runtimes, and ad-hoc scripts, with symmetric +orchestration on every node. -A cluster orchestrator with a distinctive feature set -===================================================== +## Features -* Simple and powerful -* Targeted at 1-32 nodes clusters -* Human readable services configurations and status -* Coherent alternative to a wide range of integration methods: from systemd to kubernetes -* Highly redundant cluster communications (ucast, mcast, disk, 3rd site relay) -* All nodes symmetric orchestration policies -* Orchestrate application stacks based on containers, and much more -* Provision stacks from template configurations, including disk, vg, fs, ip -* Optional CNI cluster networks, cluster DNS, ingress gateways -* DevOps, or pipelined delivery +* Targeted at 1-32 node clusters, human-readable service configurations and status +* Highly redundant cluster communications (unicast, multicast, disk, third-site relay) +* Deploy application stacks on containers, persistent or volatile volumes, or + low-level resources — disks, volume groups, filesystems, IP addresses, app launchers +* Native, zeroconf, encrypted datastores, with keys exposed as files for your deployments +* Manage everything through the API, the `om` command line, or the `ox` terminal UI -Dig Agent Features -================== +## Install -https://book.opensvc.com +See the [installation guide](https://book.opensvc.com/agent/install.html) — the +complete documentation lives there too. -Agent Installation -================== +## Play -https://book.opensvc.com/agent/install.html +Deploy a simple service: +``` +om test/svc/simple deploy --kw fs#1.type=flag --kw nodes='*' --kw orchestrate=ha +``` +Then open an `ox` session and watch it move around the cluster. + +## Examples + +Browse [ready-to-use templates](https://github.com/opensvc/opensvc_templates) — VIPs, +cluster DNS, ingress gateways, ACME, HA NFS, meshed VPN backend networks, and more. From d2c7229335c501aad2de20f47656e1fe0564bdb3 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Thu, 2 Jul 2026 10:47:06 +0200 Subject: [PATCH 05/32] Use the relaxed expand from the daemon api GetObjectPaths() which transforms this unexpected error, rendered to optimize troubleshooting: # om foooo ed Error: local (fallback caused by: unexpected get objects selector status 500 Internal Server Error) expand object selection: object not found into this expected, more readable: # om foooo ed Error: foooo: object not found --- daemon/daemonapi/get_object_selector.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/daemon/daemonapi/get_object_selector.go b/daemon/daemonapi/get_object_selector.go index 4e837f378..1f0e66f0c 100644 --- a/daemon/daemonapi/get_object_selector.go +++ b/daemon/daemonapi/get_object_selector.go @@ -20,9 +20,9 @@ func (a *DaemonAPI) GetObjectPaths(ctx echo.Context, params api.GetObjectPathsPa objectselector.WithPaths(paths), objectselector.WithLocal(true), ) - matchedPaths, err := selection.Expand() + matchedPaths, err := selection.ExpandRelaxed() if err != nil { - log.Errorf("expand selection from param selector %s: %s", params.Path, err) + log.Warnf("expand selection from param selector %s: %s", params.Path, err) return JSONProblem(ctx, http.StatusInternalServerError, "Server error", "expand selection") } result := api.ObjectPaths{} From 357c53a8fcb82418129d689780b170a25a087395 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Thu, 2 Jul 2026 15:23:43 +0200 Subject: [PATCH 06/32] Add object labels to instance.Config With: $ om cvi1 config show --section labels [labels] com.acme.foo1 = bar com.acme.foo2 = baz instance.Config now exposes: # om cvi1 instance status -o json [ { "path": "cvi1", "config": { "labels": { "com.acme.foo1": "bar", "com.acme.foo2": "baz" }, ... and the keyop selector works: $ om labels.com.acme.foo1=bar ls cvi1 --- core/instance/config.go | 7 +++++++ core/resourceid/resourceid.go | 1 + daemon/daemonapi/lib_rbac.go | 2 +- daemon/icfg/main.go | 3 ++- util/key/key.go | 2 +- 5 files changed, 12 insertions(+), 3 deletions(-) diff --git a/core/instance/config.go b/core/instance/config.go index 8387c6139..0f1aad64f 100644 --- a/core/instance/config.go +++ b/core/instance/config.go @@ -1,6 +1,7 @@ package instance import ( + "maps" "time" "github.com/opensvc/om3/v3/core/naming" @@ -8,6 +9,7 @@ import ( "github.com/opensvc/om3/v3/core/priority" "github.com/opensvc/om3/v3/core/schedule" "github.com/opensvc/om3/v3/core/topology" + "github.com/opensvc/om3/v3/util/label" "github.com/opensvc/om3/v3/util/stringslice" "github.com/opensvc/om3/v3/util/xmap" ) @@ -21,6 +23,7 @@ type ( Priority priority.T `json:"priority"` Scope []string `json:"scope"` UpdatedAt time.Time `json:"updated_at"` + Labels label.M `json:"labels,omitempty"` *ActorConfig *VolConfig @@ -96,6 +99,7 @@ func (cfg *Config) DeepCopy() *Config { newCfg.Scope = append([]string{}, cfg.Scope...) newCfg.ActorConfig = cfg.ActorConfig.DeepCopy() newCfg.VolConfig = cfg.VolConfig.DeepCopy() + newCfg.Labels = cfg.Labels.DeepCopy() return &newCfg } @@ -131,6 +135,9 @@ func ConfigEqual(a, b *Config) bool { if !stringslice.Equal(a.Scope, b.Scope) { return false } + if !maps.Equal(a.Labels, b.Labels) { + return false + } return true } diff --git a/core/resourceid/resourceid.go b/core/resourceid/resourceid.go index 0305c433a..96a7a3f63 100644 --- a/core/resourceid/resourceid.go +++ b/core/resourceid/resourceid.go @@ -27,6 +27,7 @@ func Parse(s string) (*T, error) { case s == "": case s == "env": case s == "data": + case s == "labels": case s == "DEFAULT": case strings.HasPrefix(s, "subset#"): default: diff --git a/daemon/daemonapi/lib_rbac.go b/daemon/daemonapi/lib_rbac.go index 1058fd812..a6d7991c2 100644 --- a/daemon/daemonapi/lib_rbac.go +++ b/daemon/daemonapi/lib_rbac.go @@ -262,7 +262,7 @@ func keyopRbac(grants rbac.Grants, op keyop.T) error { return fmt.Errorf("denied: %s: requires the root grant", op) } - case "env": + case "env", "labels": // allowed default: return fmt.Errorf("denied: %s: this driver group requires the root grant", op) diff --git a/daemon/icfg/main.go b/daemon/icfg/main.go index a08cb0215..71ac62da1 100644 --- a/daemon/icfg/main.go +++ b/daemon/icfg/main.go @@ -353,6 +353,7 @@ func (t *Manager) configFileCheck() error { cfg.Scope = scope cfg.UpdatedAt = mtime cfg.Priority = t.getPriority(cf) + cfg.Labels = cf.SectionMap("labels") if t.path.Kind == naming.KindVol { cfg.VolConfig = &instance.VolConfig{ Pool: cf.GetString(keyPool), @@ -471,7 +472,7 @@ func (t *Manager) getResources(cf *xconfig.T) instance.ResourceConfigs { m := make(instance.ResourceConfigs, 0) for _, section := range cf.SectionStrings() { switch section { - case "env", "DEFAULT": + case "env", "labels", "DEFAULT": continue } if resourceset.IsSubsetSection(section) { diff --git a/util/key/key.go b/util/key/key.go index ccf3447e7..ace45c8a6 100644 --- a/util/key/key.go +++ b/util/key/key.go @@ -64,7 +64,7 @@ func ParseWithDefaultSection(s, defaultSection string) (T, error) { return T{defaultSection, s}, nil case 2: switch l[0] { - case "env", "data": + case "env", "data", "labels": // "data.c.d" parses as {"data", "c.d"} return T{l[0], l[1]}, nil default: From 2eb94526a40a7ca1c17ef280ae071c958c127bb8 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Thu, 2 Jul 2026 17:04:52 +0200 Subject: [PATCH 07/32] Return a [400] Bad Request if evaluating a non-existent kw Instead of [500] Internal Server Error. Example: # om testdrbd config eval --kw app#1.starte Error: testdrbd: [400] EvalAs: keyword does not exist: "app#1.starte" --- daemon/daemonapi/get_object_config.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/daemon/daemonapi/get_object_config.go b/daemon/daemonapi/get_object_config.go index 2206ec8ab..bf7d0c71c 100644 --- a/daemon/daemonapi/get_object_config.go +++ b/daemon/daemonapi/get_object_config.go @@ -1,6 +1,7 @@ package daemonapi import ( + "errors" "net/http" "github.com/labstack/echo/v4" @@ -8,6 +9,7 @@ import ( "github.com/opensvc/om3/v3/core/instance" "github.com/opensvc/om3/v3/core/naming" "github.com/opensvc/om3/v3/core/object" + "github.com/opensvc/om3/v3/core/xconfig" "github.com/opensvc/om3/v3/daemon/api" "github.com/opensvc/om3/v3/util/key" ) @@ -71,7 +73,9 @@ func (a *DaemonAPI) GetObjectConfig(ctx echo.Context, namespace string, kind nam } if isEvaluated { - if i, err := oc.EvalAs(k, evaluatedAs); err != nil { + if i, err := oc.EvalAs(k, evaluatedAs); errors.Is(err, xconfig.ErrNoKeyword) { + return JSONProblemf(ctx, http.StatusBadRequest, "EvalAs", "%s", err) + } else if err != nil { return JSONProblemf(ctx, http.StatusInternalServerError, "EvalAs", "%s", err) } else { item.Evaluated = &i From aa42957b431d9140e36cab9e6ab8b4e34b0ffb48 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Thu, 2 Jul 2026 17:12:14 +0200 Subject: [PATCH 08/32] Honor --ignore-not-found in "o[mx] config get|eval" This behaviour is not expected: # om idontexist eval --kw orchestrate --ignore-not-found Error: prout: object not found Fix to implement this behaviour: # bin/om idontexist eval --kw orchestrate --ignore-not-found # echo $? 0 --- core/omcmd/object_config_get.go | 7 ++++++- core/oxcmd/object_config_get.go | 8 +++++++- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/core/omcmd/object_config_get.go b/core/omcmd/object_config_get.go index a4f13688b..0b24d6b70 100644 --- a/core/omcmd/object_config_get.go +++ b/core/omcmd/object_config_get.go @@ -36,7 +36,12 @@ func (t *CmdObjectConfigGet) Run(kind string) error { return err } sel := objectselector.New(mergedSelector, objectselector.WithClient(c)) - paths, err := sel.MustExpand() + var paths naming.Paths + if t.IgnoreNotFound { + paths, err = sel.ExpandRelaxed() + } else { + paths, err = sel.MustExpand() + } if err != nil { return err } diff --git a/core/oxcmd/object_config_get.go b/core/oxcmd/object_config_get.go index 471c20686..4701992c0 100644 --- a/core/oxcmd/object_config_get.go +++ b/core/oxcmd/object_config_get.go @@ -6,6 +6,7 @@ import ( "github.com/opensvc/om3/v3/core/client" "github.com/opensvc/om3/v3/core/commoncmd" + "github.com/opensvc/om3/v3/core/naming" "github.com/opensvc/om3/v3/core/objectselector" "github.com/opensvc/om3/v3/core/output" "github.com/opensvc/om3/v3/core/rawconfig" @@ -28,7 +29,12 @@ func (t *CmdObjectConfigGet) Run(kind string) error { return err } sel := objectselector.New(mergedSelector, objectselector.WithClient(c)) - paths, err := sel.MustExpand() + var paths naming.Paths + if t.IgnoreNotFound { + paths, err = sel.ExpandRelaxed() + } else { + paths, err = sel.MustExpand() + } if err != nil { return err } From e8634743b5c7acc92f6c2f72a6ac53cefb13af76 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Fri, 3 Jul 2026 09:25:53 +0200 Subject: [PATCH 09/32] Add the "make test-cover" target and "make help" "make help" prints this message: Available targets: api - Generate the api code from api.yaml build - Build om and ox compobj - Build the compliance modules pack dist - Build, strip binaries and make a tarball om - Build om ox - Build ox install - Install o[mx] to /usr/bin restart - Restart the daemon deploy - Install and restart on all nodes clean - Clean build artifacts deps - Update dependencies test - Run tests test-cover - Run tests with coverage vet - Run go static analyzer version - Update the version string from git status Available -race targets: build-race - Build om and ox if race-free compobj-race - Build the compliance modules pack if race-free om-race - Build om if race-free ox-race - Build ox if race-free test-race - Run tests with race detection --- Makefile | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Makefile b/Makefile index deea53085..c4b1d45e8 100644 --- a/Makefile +++ b/Makefile @@ -114,6 +114,10 @@ restart: test: $(GOTEST) -p 1 -timeout 60s ./... +test-cover: + $(GOTEST) -p 1 -timeout 60s -race -coverprofile=coverage.out ./... + $(GOCMD) tool cover -html=coverage.out -o coverage.html + testinfo: TEST_LOG_LEVEL=info $(GOTEST) -p 1 -timeout 60s ./... @@ -124,3 +128,28 @@ vet: $(GOVET) ./... +help: + @echo "Available targets:" + @echo " api - Generate the api code from api.yaml" + @echo " build - Build om and ox" + @echo " compobj - Build the compliance modules pack" + @echo " dist - Build, strip binaries and make a tarball" + @echo " om - Build om" + @echo " ox - Build ox" + @echo " install - Install o[mx] to /usr/bin" + @echo " restart - Restart the daemon" + @echo " deploy - Install and restart on all nodes" + @echo " clean - Clean build artifacts" + @echo " deps - Update dependencies" + @echo " test - Run tests" + @echo " test-cover - Run tests with coverage" + @echo " vet - Run go static analyzer" + @echo " version - Update the version string from git status" + @echo + @echo "Available -race targets:" + @echo " build-race - Build om and ox if race-free" + @echo " compobj-race - Build the compliance modules pack if race-free" + @echo " om-race - Build om if race-free" + @echo " ox-race - Build ox if race-free" + @echo " test-race - Run tests with race detection" + From d96378aab9f6f2bee1b7f1a146019fcba0a62ad3 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Fri, 3 Jul 2026 10:57:10 +0200 Subject: [PATCH 10/32] Sanitize command aliases in o[mx] --- core/commoncmd/object.go | 6 +- core/om/factory.go | 233 +++++++++++++++++---------------------- core/ox/factory.go | 194 +++++++++++++++----------------- 3 files changed, 193 insertions(+), 240 deletions(-) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 75f10373f..f788f4267 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -17,7 +17,7 @@ func NewCmdObjectCompliance(kind string) *cobra.Command { GroupID: GroupIDSubsystems, Use: "compliance", Short: "analyze, enforce node configuration compliance", - Aliases: []string{"compli", "comp", "com", "co"}, + Aliases: []string{"comp"}, } } @@ -25,6 +25,7 @@ func NewCmdObjectConfig(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, Use: "config", + Aliases: []string{"conf", "cf", "cfg"}, Short: "show, alter object configuration", } } @@ -42,7 +43,7 @@ func NewCmdObjectInstance(kind string) *cobra.Command { GroupID: GroupIDSubsystems, Use: "instance", Short: "query, action object instances", - Aliases: []string{"inst", "in"}, + Aliases: []string{"inst"}, } cmd.AddGroup( NewGroupQuery(), @@ -111,6 +112,7 @@ func NewCmdObjectInstanceResource(kind string) *cobra.Command { GroupID: GroupIDSubsystems, Use: "resource", Short: "query, push instance resources", + Aliases: []string{"res"}, } cmd.AddGroup( NewGroupSubsystems(), diff --git a/core/om/factory.go b/core/om/factory.go index 7c1de818d..83144bd2c 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -183,7 +183,7 @@ func newCmdDaemonEvents() *cobra.Command { Use: "events", Short: "print the daemon event stream", Long: "Print the daemon event stream\n\n" + commoncmd.UsageFlagEventFilter() + "\n" + commoncmd.UsageFlagEventTemplate(), - Aliases: []string{"eve", "even", "event"}, + Aliases: []string{"ev"}, RunE: func(cmd *cobra.Command, args []string) error { if options.Wait && !cmd.Flags().Changed("limit") { options.Limit = 1 @@ -208,10 +208,9 @@ func newCmdDaemonEvents() *cobra.Command { func newCmdDaemonRestart() *cobra.Command { var options commands.CmdDaemonRestart cmd := &cobra.Command{ - Use: "restart", - Short: "restart the daemon", - Long: "restart the daemon. Operation is asynchronous when node selector is used", - Aliases: []string{"restart"}, + Use: "restart", + Short: "restart the daemon", + Long: "restart the daemon. Operation is asynchronous when node selector is used", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -226,10 +225,9 @@ func newCmdDaemonRestart() *cobra.Command { func newCmdDaemonRun() *cobra.Command { var options commands.CmdDaemonRun cmd := &cobra.Command{ - Use: "run", - Short: "run the daemon in foreground", - Long: "Start executes a detached run", - Aliases: []string{"star"}, + Use: "run", + Short: "run the daemon in foreground", + Long: "Start executes a detached run", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -275,9 +273,8 @@ func newCmdDaemonShutdown() *cobra.Command { func newCmdDaemonStart() *cobra.Command { var options commands.CmdDaemonStart cmd := &cobra.Command{ - Use: "start", - Short: "start the daemon or a daemon subsystem", - Aliases: []string{"star"}, + Use: "start", + Short: "start the daemon or a daemon subsystem", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -576,7 +573,7 @@ func newCmdNodeChecks() *cobra.Command { cmd := &cobra.Command{ Use: "checks", Short: "run the checks, push and print the result", - Aliases: []string{"check", "chec", "che", "ch"}, + Aliases: []string{"check", "chk"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -607,10 +604,9 @@ func newCmdNodeCollectorTagAttach() *cobra.Command { var attachData string var options commands.CmdNodeCollectorTagAttach cmd := &cobra.Command{ - Use: "attach", - Short: "attach a tag to this node", - Long: "The tag must already exist in the collector.", - Aliases: []string{"atta", "att", "at", "a"}, + Use: "attach", + Short: "attach a tag to this node", + Long: "The tag must already exist in the collector.", RunE: func(cmd *cobra.Command, args []string) error { if cmd.Flag("attach-data").Changed { options.AttachData = &attachData @@ -655,9 +651,8 @@ func newCmdNodeCollectorTagCreate() *cobra.Command { func newCmdNodeCollectorTagDetach() *cobra.Command { var options commands.CmdNodeCollectorTagDetach cmd := &cobra.Command{ - Use: "detach", - Short: "detach a tag from this node", - Aliases: []string{"deta", "det", "de", "d"}, + Use: "detach", + Short: "detach a tag from this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -704,7 +699,7 @@ func newCmdNodeComplianceAttachModuleset() *cobra.Command { Use: "moduleset", Short: "attach modulesets to this node", Long: "Modules of all attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -719,10 +714,9 @@ func newCmdNodeComplianceAttachModuleset() *cobra.Command { func newCmdNodeComplianceAttachRuleset() *cobra.Command { var options commands.CmdNodeComplianceAttachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "attach rulesets to this node", - Long: "Rules of attached rulesets are exposed to modules.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "attach rulesets to this node", + Long: "Rules of attached rulesets are exposed to modules.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -759,7 +753,7 @@ func newCmdNodeComplianceCheck() *cobra.Command { cmd := &cobra.Command{ Use: "check", Short: "run modules checks", - Aliases: []string{"chec", "che", "ch"}, + Aliases: []string{"chk"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -796,9 +790,8 @@ func newCmdNodeComplianceFix() *cobra.Command { func newCmdNodeComplianceFixable() *cobra.Command { var options commands.CmdNodeComplianceFixable cmd := &cobra.Command{ - Use: "fixable", - Short: "run modules fixable-tests", - Aliases: []string{"fixabl", "fixab", "fixa"}, + Use: "fixable", + Short: "run modules fixable-tests", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -819,7 +812,7 @@ func newCmdNodeComplianceDetachModuleset() *cobra.Command { Use: "moduleset", Short: "detach modulesets from this node", Long: "Modules of attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -834,10 +827,9 @@ func newCmdNodeComplianceDetachModuleset() *cobra.Command { func newCmdNodeComplianceDetachRuleset() *cobra.Command { var options commands.CmdNodeComplianceDetachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "detach rulesets from this node", - Long: "Rules of attached rulesets are made available to their module.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "detach rulesets from this node", + Long: "Rules of attached rulesets are made available to their module.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -852,9 +844,8 @@ func newCmdNodeComplianceDetachRuleset() *cobra.Command { func newCmdNodeComplianceEnv() *cobra.Command { var options commands.CmdNodeComplianceEnv cmd := &cobra.Command{ - Use: "env", - Short: "show the env variables set for modules run", - Aliases: []string{"en"}, + Use: "env", + Short: "show the env variables set for modules run", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -870,9 +861,9 @@ func newCmdNodeComplianceEnv() *cobra.Command { func newCmdNodeComplianceListModules() *cobra.Command { var options commands.CmdNodeComplianceListModules cmd := &cobra.Command{ - Use: "modules", + Use: "module", Short: "list modules available on this node", - Aliases: []string{"module", "modul", "modu", "mod"}, + Aliases: []string{"mod", "modules"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -888,7 +879,7 @@ func newCmdNodeComplianceListModuleset() *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "list modulesets available to this node", - Aliases: []string{"modulesets"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -903,9 +894,8 @@ func newCmdNodeComplianceListModuleset() *cobra.Command { func newCmdNodeComplianceListRuleset() *cobra.Command { var options commands.CmdNodeComplianceListRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "list rulesets available to this node", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "list rulesets available to this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -922,7 +912,7 @@ func newCmdNodeComplianceShowModuleset() *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "show modulesets and modules attached to this node", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -937,9 +927,8 @@ func newCmdNodeComplianceShowModuleset() *cobra.Command { func newCmdNodeComplianceShowRuleset() *cobra.Command { var options commands.CmdNodeComplianceShowRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "show rules contextualized for this node", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "show rules contextualized for this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -990,7 +979,7 @@ func newCmdNodeEdit() *cobra.Command { Use: "edit", Short: "edit the node configuration", Hidden: true, - Aliases: []string{"ed", "edi"}, + Aliases: []string{"ed"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1026,7 +1015,7 @@ func newCmdNodeEditConfig() *cobra.Command { cmd := &cobra.Command{ Use: "config", Short: "edit the node configuration", - Aliases: []string{"conf", "co", "cf", "cfg"}, + Aliases: []string{"conf", "cf", "cfg"}, Hidden: true, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() @@ -1122,7 +1111,7 @@ func newCmdNodeLogs() *cobra.Command { cmd := &cobra.Command{ GroupID: commoncmd.GroupIDQuery, Use: "logs", - Aliases: []string{"logs", "log", "lo"}, + Aliases: []string{"log"}, Short: "show this node logs", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() @@ -1157,9 +1146,8 @@ func newCmdNodeList() *cobra.Command { func newCmdNodeSCSIPRKey() *cobra.Command { var options commands.CmdNodePRKey cmd := &cobra.Command{ - Use: "prkey", - Short: "show the scsi3 persistent reservation key of this node", - Aliases: []string{"prk", "prke"}, + Use: "prkey", + Short: "show the scsi3 persistent reservation key of this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1221,10 +1209,9 @@ func newCmdNodeScheduleList() *cobra.Command { func newCmdNodePushasset() *cobra.Command { var options commands.CmdNodePushAsset cmd := &cobra.Command{ - Use: "pushasset", - Hidden: true, - Short: "run the node discovery, push and print the result", - Aliases: []string{"pushasse", "pushass", "pushas"}, + Use: "pushasset", + Hidden: true, + Short: "run the node discovery, push and print the result", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1239,9 +1226,8 @@ func newCmdNodePushasset() *cobra.Command { func newCmdNodePushAsset() *cobra.Command { var options commands.CmdNodePushAsset cmd := &cobra.Command{ - Use: "asset", - Short: "run the node discovery, push and print the result", - Aliases: []string{"asse", "ass", "as"}, + Use: "asset", + Short: "run the node discovery, push and print the result", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1261,7 +1247,7 @@ func newCmdNodePushdisk() *cobra.Command { Use: "pushdisk", Hidden: true, Short: "run the disk discovery, push and print the result", - Aliases: []string{"pushdisks", "pushdis", "psuhdi"}, + Aliases: []string{"pushdisks"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1278,7 +1264,7 @@ func newCmdNodePushDisk() *cobra.Command { cmd := &cobra.Command{ Use: "disk", Short: "run the disk discovery, push and print the result", - Aliases: []string{"disks", "dis", "di"}, + Aliases: []string{"disks"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1295,10 +1281,9 @@ func newCmdNodePushDisk() *cobra.Command { func newCmdNodePushpkg() *cobra.Command { var options commands.CmdNodePushPkg cmd := &cobra.Command{ - Use: "pushpkg", - Hidden: true, - Short: "run the node installed packages discovery, push and print the result", - Aliases: []string{"pushpk"}, + Use: "pushpkg", + Hidden: true, + Short: "run the node installed packages discovery, push and print the result", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1313,9 +1298,8 @@ func newCmdNodePushpkg() *cobra.Command { func newCmdNodePushPkg() *cobra.Command { var options commands.CmdNodePushPkg cmd := &cobra.Command{ - Use: "pkg", - Short: "run the node installed packages discovery, push and print the result", - Aliases: []string{"pk"}, + Use: "pkg", + Short: "run the node installed packages discovery, push and print the result", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1335,7 +1319,7 @@ func newCmdNodeRegister() *cobra.Command { Use: "register", Short: "initial login on the collector", Long: "Obtain a registration id from the collector, store it in the node configuration node.uuid keyword. This uuid is then used to authenticate the node in collector communications.", - Aliases: []string{"registe", "regist", "regis", "regi", "reg", "re"}, + Aliases: []string{"reg"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1401,10 +1385,9 @@ over a service declaring stonith=true`, func newCmdNodeSysreport() *cobra.Command { var options commands.CmdNodeSysreport cmd := &cobra.Command{ - Use: "sysreport", - Short: "collect system data and push it to the collector", - Long: "Push system report to the collector for archiving and diff analysis. The --force option resend all monitored files and outputs to the collector instead of only those that changed since the last sysreport.", - Aliases: []string{"sysrepor", "sysrepo", "sysrep", "sysre", "sysr", "sys", "sy"}, + Use: "sysreport", + Short: "collect system data and push it to the collector", + Long: "Push system report to the collector for archiving and diff analysis. The --force option resend all monitored files and outputs to the collector instead of only those that changed since the last sysreport.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1456,7 +1439,7 @@ func newCmdNodeValidateConfig() *cobra.Command { cmd := &cobra.Command{ Use: "config", Short: "verify the node configuration syntax", - Aliases: []string{"conf", "co", "cf", "cfg"}, + Aliases: []string{"conf", "cf", "cfg"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1565,9 +1548,8 @@ func newCmdObjectCertificatePKCS(kind string) *cobra.Command { func newCmdObjectPrint(kind string) *cobra.Command { cmd := &cobra.Command{ - Use: "print", - Short: "print information about the object", - Aliases: []string{"prin", "pri", "pr"}, + Use: "print", + Short: "print information about the object", } cmd.AddGroup( commoncmd.NewGroupQuery(), @@ -1577,9 +1559,8 @@ func newCmdObjectPrint(kind string) *cobra.Command { func newCmdObjectPush(kind string) *cobra.Command { return &cobra.Command{ - Use: "push", - Short: "push information about the object to the collector", - Aliases: []string{"push", "pus", "pu"}, + Use: "push", + Short: "push information about the object to the collector", } } @@ -1594,10 +1575,9 @@ func newCmdObjectCollectorTagAttach(kind string) *cobra.Command { var attachData string var options commands.CmdObjectCollectorTagAttach cmd := &cobra.Command{ - Use: "attach", - Short: "attach a tag to this node", - Long: "The tag must already exist in the collector.", - Aliases: []string{"atta", "att", "at", "a"}, + Use: "attach", + Short: "attach a tag to this node", + Long: "The tag must already exist in the collector.", RunE: func(cmd *cobra.Command, args []string) error { if cmd.Flag("attach-data").Changed { options.AttachData = &attachData @@ -1642,9 +1622,8 @@ func newCmdObjectCollectorTagCreate(kind string) *cobra.Command { func newCmdObjectCollectorTagDetach(kind string) *cobra.Command { var options commands.CmdObjectCollectorTagDetach cmd := &cobra.Command{ - Use: "detach", - Short: "detach a tag from this node", - Aliases: []string{"deta", "det", "de", "d"}, + Use: "detach", + Short: "detach a tag from this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1687,17 +1666,15 @@ func newCmdObjectCollectorTagShow(kind string) *cobra.Command { func newCmdObjectComplianceAttach(kind string) *cobra.Command { return &cobra.Command{ - Use: "attach", - Short: "attach modulesets and rulesets to the node", - Aliases: []string{"attac", "atta", "att", "at"}, + Use: "attach", + Short: "attach modulesets and rulesets to the node", } } func newCmdObjectComplianceDetach(kind string) *cobra.Command { return &cobra.Command{ - Use: "detach", - Short: "detach modulesets and rulesets from the node", - Aliases: []string{"detac", "deta", "det", "de"}, + Use: "detach", + Short: "detach modulesets and rulesets from the node", } } @@ -1776,7 +1753,7 @@ func newCmdObjectEditConfig(kind string) *cobra.Command { Use: "config", Short: "edit selected object and instance configuration", Hidden: true, - Aliases: []string{"conf", "co", "cf", "cfg"}, + Aliases: []string{"conf", "cf", "cfg"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1795,7 +1772,7 @@ func newCmdObjectComplianceAttachModuleset(kind string) *cobra.Command { Use: "moduleset", Short: "attach modulesets to this object", Long: "Modules of attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1809,10 +1786,9 @@ func newCmdObjectComplianceAttachModuleset(kind string) *cobra.Command { func newCmdObjectComplianceAttachRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceAttachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "attach rulesets to this object", - Long: "Rules of attached rulesets are exposed to modules.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "attach rulesets to this object", + Long: "Rules of attached rulesets are exposed to modules.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1848,7 +1824,7 @@ func newCmdObjectComplianceCheck(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "check", Short: "run modules checks", - Aliases: []string{"chec", "che", "ch"}, + Aliases: []string{"chk"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1885,9 +1861,8 @@ func newCmdObjectComplianceFix(kind string) *cobra.Command { func newCmdObjectComplianceFixable(kind string) *cobra.Command { var options commands.CmdObjectComplianceFixable cmd := &cobra.Command{ - Use: "fixable", - Short: "run modules fixable-tests", - Aliases: []string{"fixabl", "fixab", "fixa"}, + Use: "fixable", + Short: "run modules fixable-tests", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1908,7 +1883,7 @@ func newCmdObjectComplianceDetachModuleset(kind string) *cobra.Command { Use: "moduleset", Short: "detach modulesets from this object", Long: "Modules of attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1922,10 +1897,9 @@ func newCmdObjectComplianceDetachModuleset(kind string) *cobra.Command { func newCmdObjectComplianceDetachRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceDetachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "detach rulesets from this object", - Long: "Rules of attached rulesets are made available to their module.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "detach rulesets from this object", + Long: "Rules of attached rulesets are made available to their module.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1939,9 +1913,8 @@ func newCmdObjectComplianceDetachRuleset(kind string) *cobra.Command { func newCmdObjectComplianceEnv(kind string) *cobra.Command { var options commands.CmdObjectComplianceEnv cmd := &cobra.Command{ - Use: "env", - Short: "show the env variables set for a module run", - Aliases: []string{"en"}, + Use: "env", + Short: "show the env variables set for a module run", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1959,7 +1932,7 @@ func newCmdObjectComplianceListModules(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "modules", Short: "list modules available on this object", - Aliases: []string{"module", "modul", "modu", "mod"}, + Aliases: []string{"mod"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1974,7 +1947,7 @@ func newCmdObjectComplianceListModuleset(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "list modulesets available to this object", - Aliases: []string{"modulesets"}, + Aliases: []string{"modulesets", "modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1990,7 +1963,7 @@ func newCmdObjectComplianceListRuleset(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "ruleset", Short: "list rulesets available to this object", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Aliases: []string{"rulesets"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -2006,7 +1979,7 @@ func newCmdObjectComplianceShowModuleset(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "show modulesets and modules attached to this object", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -2020,9 +1993,8 @@ func newCmdObjectComplianceShowModuleset(kind string) *cobra.Command { func newCmdObjectComplianceShowRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceShowRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "show rules contextualized for to this object", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "show rules contextualized for to this object", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -2252,7 +2224,7 @@ func newCmdObjectLogs(kind string) *cobra.Command { cmd := &cobra.Command{ GroupID: commoncmd.GroupIDQuery, Use: "logs", - Aliases: []string{"logs", "log", "lo"}, + Aliases: []string{"log"}, Short: "show object logs", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) @@ -2300,9 +2272,8 @@ func newCmdObjectConfigShow(kind string) *cobra.Command { func newCmdObjectConfigMtime(kind string) *cobra.Command { var options commands.CmdObjectConfigMtime cmd := &cobra.Command{ - Use: "mtime", - Short: "print the object configuration file modification time", - Aliases: []string{"mtim", "mti", "mt", "m"}, + Use: "mtime", + Short: "print the object configuration file modification time", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -2623,7 +2594,7 @@ func newCmdObjectInstanceStatus(kind string) *cobra.Command { cmd := &cobra.Command{ GroupID: commoncmd.GroupIDQuery, Use: "status", - Aliases: []string{"statu", "stat", "sta", "st"}, + Aliases: []string{"stat"}, Short: "print the object instances status", Long: `Resources Flags: @@ -3104,7 +3075,7 @@ func newCmdObjectStatus(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "status", Hidden: true, - Aliases: []string{"statu", "stat", "sta", "st"}, + Aliases: []string{"stat", "st"}, Long: "Internal, for use by the daemon scheduler. This command is silent. Only the exitcode holds information. The exitcode is set to the instance avail status.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) @@ -3274,7 +3245,7 @@ func newCmdObjectValidateConfig(kind string) *cobra.Command { Use: "config", Short: "verify the object configuration syntax", Hidden: true, - Aliases: []string{"conf", "co", "cf", "cfg"}, + Aliases: []string{"conf", "cf", "cfg"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -3337,7 +3308,7 @@ func newCmdNodePrintConfig() *cobra.Command { cmd := newCmdNodeConfigShow() cmd.Use = "config" cmd.Hidden = true - cmd.Aliases = []string{"conf", "co", "cf", "cfg"} + cmd.Aliases = []string{"conf", "cf", "cfg"} return cmd } @@ -3391,7 +3362,7 @@ func newCmdNodeUnset() *cobra.Command { func newCmdNodeValidate() *cobra.Command { cmd := newCmdNodeConfigValidate() cmd.Hidden = true - cmd.Aliases = []string{"validat", "valida", "valid", "val"} + cmd.Aliases = []string{"valid", "val"} return cmd } @@ -3447,7 +3418,7 @@ func newCmdObjectUnset(kind string) *cobra.Command { func newCmdObjectValidate(kind string) *cobra.Command { cmd := newCmdObjectConfigValidate(kind) cmd.Hidden = true - cmd.Aliases = []string{"validat", "valida", "valid", "vali", "val"} + cmd.Aliases = []string{"valid", "val"} return cmd } @@ -3469,7 +3440,7 @@ func newCmdObjectPrintConfig(kind string) *cobra.Command { cmd := newCmdObjectConfigShow(kind) cmd.Use = "config" cmd.Hidden = true - cmd.Aliases = []string{"conf", "co", "cf", "cfg"} + cmd.Aliases = []string{"conf", "cf", "cfg"} return cmd } @@ -3489,6 +3460,7 @@ func newCmdNodePrintCapabilities() *cobra.Command { cmd := newCmdNodeCapabilitiesList() cmd.Hidden = true cmd.Aliases = []string{"cap", "caps", "capa"} + cmd.Use = "capabilities" return cmd } @@ -3496,6 +3468,7 @@ func newCmdNodeScanCapabilities() *cobra.Command { cmd := newCmdNodeCapabilitiesScan() cmd.Hidden = true cmd.Aliases = []string{"cap", "caps", "capa"} + cmd.Use = "capabilities" return cmd } diff --git a/core/ox/factory.go b/core/ox/factory.go index 8443a85d4..9403eef82 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -138,7 +138,7 @@ func newCmdDaemonEvents() *cobra.Command { Short: "print the daemon event stream", Long: "Print the daemon event stream\n\n" + commoncmd.UsageFlagEventFilter() + "\n" + commoncmd.UsageFlagEventTemplate(), - Aliases: []string{"eve", "even", "event"}, + Aliases: []string{"ev"}, RunE: func(cmd *cobra.Command, args []string) error { options.Quiet = quietFlag if options.Wait && !cmd.Flags().Changed("limit") { @@ -164,10 +164,9 @@ func newCmdDaemonEvents() *cobra.Command { func newCmdDaemonRestart() *cobra.Command { var options commands.CmdDaemonRestart cmd := &cobra.Command{ - Use: "restart", - Short: "restart the daemon", - Long: "restart the daemon. Operation is asynchronous when node selector is used", - Aliases: []string{"restart"}, + Use: "restart", + Short: "restart the daemon", + Long: "restart the daemon. Operation is asynchronous when node selector is used", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -482,7 +481,7 @@ func newCmdNodeChecks() *cobra.Command { cmd := &cobra.Command{ Use: "checks", Short: "run the checks, push and print the result", - Aliases: []string{"check", "chec", "che", "ch"}, + Aliases: []string{"check", "chk"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -512,10 +511,9 @@ func newCmdNodeCollectorTagAttach() *cobra.Command { var attachData string var options commands.CmdNodeCollectorTagAttach cmd := &cobra.Command{ - Use: "attach", - Short: "attach a tag to this node", - Long: "The tag must already exist in the collector.", - Aliases: []string{"atta", "att", "at", "a"}, + Use: "attach", + Short: "attach a tag to this node", + Long: "The tag must already exist in the collector.", RunE: func(cmd *cobra.Command, args []string) error { if cmd.Flag("attach-data").Changed { options.AttachData = &attachData @@ -561,9 +559,8 @@ func newCmdNodeCollectorTagCreate() *cobra.Command { func newCmdNodeCollectorTagDetach() *cobra.Command { var options commands.CmdNodeCollectorTagDetach cmd := &cobra.Command{ - Use: "detach", - Short: "detach a tag from this node", - Aliases: []string{"deta", "det", "de", "d"}, + Use: "detach", + Short: "detach a tag from this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -612,7 +609,7 @@ func newCmdNodeComplianceAttachModuleset() *cobra.Command { Use: "moduleset", Short: "attach modulesets to this node", Long: "Modules of all attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -627,10 +624,9 @@ func newCmdNodeComplianceAttachModuleset() *cobra.Command { func newCmdNodeComplianceAttachRuleset() *cobra.Command { var options commands.CmdNodeComplianceAttachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "attach rulesets to this node", - Long: "Rules of attached rulesets are exposed to modules.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "attach rulesets to this node", + Long: "Rules of attached rulesets are exposed to modules.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -667,7 +663,7 @@ func newCmdNodeComplianceCheck() *cobra.Command { cmd := &cobra.Command{ Use: "check", Short: "run modules checks", - Aliases: []string{"chec", "che", "ch"}, + Aliases: []string{"chk"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -704,9 +700,8 @@ func newCmdNodeComplianceFix() *cobra.Command { func newCmdNodeComplianceFixable() *cobra.Command { var options commands.CmdNodeComplianceFixable cmd := &cobra.Command{ - Use: "fixable", - Short: "run modules fixable-tests", - Aliases: []string{"fixabl", "fixab", "fixa"}, + Use: "fixable", + Short: "run modules fixable-tests", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -727,7 +722,7 @@ func newCmdNodeComplianceDetachModuleset() *cobra.Command { Use: "moduleset", Short: "detach modulesets from this node", Long: "Modules of attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -742,10 +737,9 @@ func newCmdNodeComplianceDetachModuleset() *cobra.Command { func newCmdNodeComplianceDetachRuleset() *cobra.Command { var options commands.CmdNodeComplianceDetachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "detach rulesets from this node", - Long: "Rules of attached rulesets are made available to their module.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "detach rulesets from this node", + Long: "Rules of attached rulesets are made available to their module.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -760,9 +754,8 @@ func newCmdNodeComplianceDetachRuleset() *cobra.Command { func newCmdNodeComplianceEnv() *cobra.Command { var options commands.CmdNodeComplianceEnv cmd := &cobra.Command{ - Use: "env", - Short: "show the env variables set for modules run", - Aliases: []string{"en"}, + Use: "env", + Short: "show the env variables set for modules run", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -778,9 +771,9 @@ func newCmdNodeComplianceEnv() *cobra.Command { func newCmdNodeComplianceListModules() *cobra.Command { var options commands.CmdNodeComplianceListModules cmd := &cobra.Command{ - Use: "modules", + Use: "module", Short: "list modules available on this node", - Aliases: []string{"module", "modul", "modu", "mod"}, + Aliases: []string{"mod", "modules"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -796,7 +789,7 @@ func newCmdNodeComplianceListModuleset() *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "list modulesets available to this node", - Aliases: []string{"modulesets"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -811,9 +804,8 @@ func newCmdNodeComplianceListModuleset() *cobra.Command { func newCmdNodeComplianceListRuleset() *cobra.Command { var options commands.CmdNodeComplianceListRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "list rulesets available to this node", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "list rulesets available to this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -830,7 +822,7 @@ func newCmdNodeComplianceShowModuleset() *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "show modulesets and modules attached to this node", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -845,9 +837,8 @@ func newCmdNodeComplianceShowModuleset() *cobra.Command { func newCmdNodeComplianceShowRuleset() *cobra.Command { var options commands.CmdNodeComplianceShowRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "show rules contextualized for this node", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "show rules contextualized for this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1086,9 +1077,9 @@ func newCmdNodeSystemUser() *cobra.Command { func newCmdNodeConfigEdit() *cobra.Command { var options commands.CmdNodeConfigEdit cmd := &cobra.Command{ - Use: "edit", - Short: "edit the node configuration", - Aliases: []string{"ed", "edi"}, + Use: "edit", + Short: "edit the node configuration", + Aliases: []string{"ed"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1226,7 +1217,7 @@ func newCmdNodeLogs() *cobra.Command { cmd := &cobra.Command{ GroupID: commoncmd.GroupIDQuery, Use: "logs", - Aliases: []string{"logs", "log", "lo"}, + Aliases: []string{"log"}, Short: "show this node logs", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() @@ -1260,9 +1251,8 @@ func newCmdNodeList() *cobra.Command { func newCmdNodeSCSIPRKey() *cobra.Command { var options commands.CmdNodePRKey cmd := &cobra.Command{ - Use: "prkey", - Short: "show the scsi3 persistent reservation key of this node", - Aliases: []string{"prk", "prke"}, + Use: "prkey", + Short: "show the scsi3 persistent reservation key of this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1301,9 +1291,8 @@ func newCmdObjectScheduleList(kind string) *cobra.Command { func newCmdNodePushAsset() *cobra.Command { var options commands.CmdNodePushAsset cmd := &cobra.Command{ - Use: "asset", - Short: "run the node discovery, push and print the result", - Aliases: []string{"asse", "ass", "as"}, + Use: "asset", + Short: "run the node discovery, push and print the result", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1321,7 +1310,7 @@ func newCmdNodePushDisk() *cobra.Command { cmd := &cobra.Command{ Use: "disk", Short: "run the disk discovery, push and print the result", - Aliases: []string{"disks", "dis", "di"}, + Aliases: []string{"disks"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1337,9 +1326,8 @@ func newCmdNodePushDisk() *cobra.Command { func newCmdNodePushPkg() *cobra.Command { var options commands.CmdNodePushPkg cmd := &cobra.Command{ - Use: "pkg", - Short: "run the node installed packages discovery, push and print the result", - Aliases: []string{"pk"}, + Use: "pkg", + Short: "run the node installed packages discovery, push and print the result", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1358,7 +1346,7 @@ func newCmdNodeRegister() *cobra.Command { Use: "register", Short: "initial login on the collector", Long: "Obtain a registration id from the collector, store it in the node configuration node.uuid keyword. This uuid is then used to authenticate the node in collector communications.", - Aliases: []string{"registe", "regist", "regis", "regi", "reg", "re"}, + Aliases: []string{"reg"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1391,10 +1379,9 @@ func newCmdNodeRelayStatus() *cobra.Command { func newCmdNodeSysreport() *cobra.Command { var options commands.CmdNodeSysreport cmd := &cobra.Command{ - Use: "sysreport", - Short: "collect system data and push it to the collector", - Long: "Push system report to the collector for archiving and diff analysis. The --force option resend all monitored files and outputs to the collector instead of only those that changed since the last sysreport.", - Aliases: []string{"sysrepor", "sysrepo", "sysrep", "sysre", "sysr", "sys", "sy"}, + Use: "sysreport", + Short: "collect system data and push it to the collector", + Long: "Push system report to the collector for archiving and diff analysis. The --force option resend all monitored files and outputs to the collector instead of only those that changed since the last sysreport.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run() }, @@ -1498,17 +1485,15 @@ func newCmdObjectCertificatePKCS(kind string) *cobra.Command { func newCmdObjectPrint(kind string) *cobra.Command { return &cobra.Command{ - Use: "print", - Short: "print information about the object", - Aliases: []string{"prin", "pri", "pr"}, + Use: "print", + Short: "print information about the object", } } func newCmdObjectPush(kind string) *cobra.Command { return &cobra.Command{ - Use: "push", - Short: "push information about the object to the collector", - Aliases: []string{"push", "pus", "pu"}, + Use: "push", + Short: "push information about the object to the collector", } } @@ -1523,10 +1508,9 @@ func newCmdObjectCollectorTagAttach(kind string) *cobra.Command { var attachData string var options commands.CmdObjectCollectorTagAttach cmd := &cobra.Command{ - Use: "attach", - Short: "attach a tag to this node", - Long: "The tag must already exist in the collector.", - Aliases: []string{"atta", "att", "at", "a"}, + Use: "attach", + Short: "attach a tag to this node", + Long: "The tag must already exist in the collector.", RunE: func(cmd *cobra.Command, args []string) error { if cmd.Flag("attach-data").Changed { options.AttachData = &attachData @@ -1544,9 +1528,8 @@ func newCmdObjectCollectorTagAttach(kind string) *cobra.Command { func newCmdObjectCollectorTagDetach(kind string) *cobra.Command { var options commands.CmdObjectCollectorTagDetach cmd := &cobra.Command{ - Use: "detach", - Short: "detach a tag from this node", - Aliases: []string{"deta", "det", "de", "d"}, + Use: "detach", + Short: "detach a tag from this node", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1575,17 +1558,15 @@ func newCmdObjectCollectorTagShow(kind string) *cobra.Command { func newCmdObjectComplianceAttach(kind string) *cobra.Command { return &cobra.Command{ - Use: "attach", - Short: "attach modulesets and rulesets to the node", - Aliases: []string{"attac", "atta", "att", "at"}, + Use: "attach", + Short: "attach modulesets and rulesets to the node", } } func newCmdObjectComplianceDetach(kind string) *cobra.Command { return &cobra.Command{ - Use: "detach", - Short: "detach modulesets and rulesets from the node", - Aliases: []string{"detac", "deta", "det", "de"}, + Use: "detach", + Short: "detach modulesets and rulesets from the node", } } @@ -1709,7 +1690,7 @@ func newCmdObjectComplianceAttachModuleset(kind string) *cobra.Command { Use: "moduleset", Short: "attach modulesets to this object", Long: "Modules of attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1723,10 +1704,9 @@ func newCmdObjectComplianceAttachModuleset(kind string) *cobra.Command { func newCmdObjectComplianceAttachRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceAttachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "attach rulesets to this object", - Long: "Rules of attached rulesets are exposed to modules.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "attach rulesets to this object", + Long: "Rules of attached rulesets are exposed to modules.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1762,7 +1742,7 @@ func newCmdObjectComplianceCheck(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "check", Short: "run modules checks", - Aliases: []string{"chec", "che", "ch"}, + Aliases: []string{"chk"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1822,7 +1802,7 @@ func newCmdObjectComplianceDetachModuleset(kind string) *cobra.Command { Use: "moduleset", Short: "detach modulesets from this object", Long: "Modules of attached modulesets are checked on schedule.", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1836,10 +1816,9 @@ func newCmdObjectComplianceDetachModuleset(kind string) *cobra.Command { func newCmdObjectComplianceDetachRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceDetachRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "detach rulesets from this object", - Long: "Rules of attached rulesets are made available to their module.", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "detach rulesets from this object", + Long: "Rules of attached rulesets are made available to their module.", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1853,9 +1832,8 @@ func newCmdObjectComplianceDetachRuleset(kind string) *cobra.Command { func newCmdObjectComplianceEnv(kind string) *cobra.Command { var options commands.CmdObjectComplianceEnv cmd := &cobra.Command{ - Use: "env", - Short: "show the env variables set for a module run", - Aliases: []string{"en"}, + Use: "env", + Short: "show the env variables set for a module run", RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1871,9 +1849,9 @@ func newCmdObjectComplianceEnv(kind string) *cobra.Command { func newCmdObjectComplianceListModules(kind string) *cobra.Command { var options commands.CmdObjectComplianceListModules cmd := &cobra.Command{ - Use: "modules", - Short: "list modules available on this object", - Aliases: []string{"module", "modul", "modu", "mod"}, + Use: "modules", + Short: "list modules available on this object", + Aliases: []string{"mod"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1886,9 +1864,9 @@ func newCmdObjectComplianceListModules(kind string) *cobra.Command { func newCmdObjectComplianceListModuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceListModuleset cmd := &cobra.Command{ - Use: "moduleset", - Short: "list modulesets available to this object", - Aliases: []string{"modulesets"}, + Use: "moduleset", + Short: "list modulesets available to this object", + Aliases: []string{"modulesets", "modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1902,9 +1880,9 @@ func newCmdObjectComplianceListModuleset(kind string) *cobra.Command { func newCmdObjectComplianceListRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceListRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "list rulesets available to this object", - Aliases: []string{"rulese", "rules", "rule", "rul", "ru"}, + Use: "ruleset", + Short: "list rulesets available to this object", + Aliases: []string{"rulesets"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -1920,7 +1898,7 @@ func newCmdObjectComplianceShowModuleset(kind string) *cobra.Command { cmd := &cobra.Command{ Use: "moduleset", Short: "show modulesets and modules attached to this object", - Aliases: []string{"modulese", "modules", "module", "modul", "modu", "mod", "mo"}, + Aliases: []string{"modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) }, @@ -2472,8 +2450,8 @@ func newCmdObjectInstancePGUpdate(kind string) *cobra.Command { func newCmdObjectInstanceStatus(kind string) *cobra.Command { var options commands.CmdObjectInstanceStatus cmd := &cobra.Command{ - Use: "status", - Aliases: []string{"statu", "stat", "sta", "st"}, + Use: "status", + Aliases: []string{"stat"}, Short: "print the object instances status", Long: `Resources Flags: @@ -3043,7 +3021,7 @@ func newCmdNodeEditConfig() *cobra.Command { cmd := newCmdNodeConfigEdit() cmd.Hidden = true cmd.Use = "config" - cmd.Aliases = []string{"confi", "conf", "con", "co", "c", "cf", "cfg"} + cmd.Aliases = []string{"conf", "cf", "cfg"} return cmd } @@ -3063,7 +3041,7 @@ func newCmdNodePrintConfig() *cobra.Command { cmd := newCmdNodeConfigShow() cmd.Hidden = true cmd.Use = "config" - cmd.Aliases = []string{"conf", "co", "cf", "cfg"} + cmd.Aliases = []string{"conf", "cf", "cfg"} return cmd } @@ -3128,7 +3106,7 @@ func newCmdNodeValidateConfig() *cobra.Command { cmd := newCmdNodeConfigValidate() cmd.Hidden = true cmd.Use = "config" - cmd.Aliases = []string{"confi", "conf", "con", "co", "c"} + cmd.Aliases = []string{"conf", "cf", "cfg"} return cmd } @@ -3148,7 +3126,7 @@ func newCmdObjectPrintConfig(kind string) *cobra.Command { cmd := newCmdObjectConfigShow(kind) cmd.Hidden = true cmd.Use = "config" - cmd.Aliases = []string{"conf", "co", "cf", "cfg"} + cmd.Aliases = []string{"conf", "cf", "cfg"} return cmd } From 559380e3a121afc2de36280dc48b20567927f368 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Fri, 3 Jul 2026 11:43:47 +0200 Subject: [PATCH 11/32] Add the ReplacedBy field to the "ips_per_node" net kw And fix a formatting bug in the "config validate" COMMENT. --- core/object/node_keywords.go | 1 + core/xconfig/validate.go | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/core/object/node_keywords.go b/core/object/node_keywords.go index 43a07c472..05b5626ab 100644 --- a/core/object/node_keywords.go +++ b/core/object/node_keywords.go @@ -1209,6 +1209,7 @@ var ( Converter: "int", Default: "1024", Deprecated: "3.0.0", + ReplacedBy: "mask_per_node", Option: "ips_per_node", Section: "network", Text: keywords.NewText(fs, "text/kw/node/network.routed_bridge.ips_per_node"), diff --git a/core/xconfig/validate.go b/core/xconfig/validate.go index efd4dd59c..89b182426 100644 --- a/core/xconfig/validate.go +++ b/core/xconfig/validate.go @@ -134,7 +134,7 @@ func (t T) NewAlertEval(k key.T, did driver.ID, comment string) Alert { func (t T) NewAlertDeprecated(k key.T, did driver.ID, release, replacedBy string) Alert { comment := fmt.Sprintf("since %s", release) if replacedBy != "" { - comment += fmt.Sprintf("replaced by %s", replacedBy) + comment += fmt.Sprintf(", replaced by %s", replacedBy) } return Alert{ Path: t.Path, From 8497a6239c6555e9986eb3f62da1affe96a5d60b Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Fri, 3 Jul 2026 16:31:23 +0200 Subject: [PATCH 12/32] Fix the routedbridge network split checker and allocator The math and boundary conditions are all wrong. --- drivers/networkroutedbridge/main.go | 99 ++++++++++++++++++++++------- 1 file changed, 75 insertions(+), 24 deletions(-) diff --git a/drivers/networkroutedbridge/main.go b/drivers/networkroutedbridge/main.go index 4761fd7fc..c9ba67801 100644 --- a/drivers/networkroutedbridge/main.go +++ b/drivers/networkroutedbridge/main.go @@ -4,8 +4,8 @@ package networkroutedbridge import ( "fmt" - "math" "math/big" + "math/bits" "net" "strings" @@ -123,6 +123,23 @@ func (t *T) bridgeIP() (net.IP, error) { return ip, nil } +func ipsToMaskOnes(requestedIPs uint64, totalBits int) (int, error) { + if requestedIPs == 0 { + return totalBits, nil + } + + // Find the next highest power of 2. + // Example: 250 IPs -> 250-1 = 249. Binary length of 249 is 8 bits. 2^8 = 256. + hostBits := bits.Len64(requestedIPs - 1) + + if hostBits > totalBits { + return 0, fmt.Errorf("requested allocation size of %d IPs exceeds maximum %d-bit address space", requestedIPs, totalBits) + } + + ones := totalBits - hostBits + return ones, nil +} + func (t *T) allocateSubnets() error { subnetMap, err := t.subnets() if err != nil { @@ -135,21 +152,22 @@ func (t *T) allocateSubnets() error { } } + ip, netwk, err := net.ParseCIDR(t.Network()) + if err != nil { + return err + } + ones, bits := netwk.Mask.Size() + maskPerNode := t.GetInt("mask_per_node") if maskPerNode <= 0 { ipsPerNode := t.GetInt("ips_per_node") if ipsPerNode <= 0 { return fmt.Errorf("either mask_per_node or ips_per_node must be set to a value greater than 0") } - if ipsPerNode&(ipsPerNode-1) == 1 { - return fmt.Errorf("ips_per_node must be a power of 2") + maskPerNode, err = ipsToMaskOnes(uint64(ipsPerNode), bits) + if err != nil { + return err } - maskPerNode = int(math.Log2(float64(ipsPerNode))) - } - - ip, netwk, err := net.ParseCIDR(t.Network()) - if err != nil { - return err } nodes, err := t.Nodes() @@ -161,11 +179,10 @@ func (t *T) allocateSubnets() error { return err } - _, bits := netwk.Mask.Size() m := make(map[string]string) for i, nodename := range nodes { - nodeIp, subnet, err := computeSubnet(ip, int64(i), maskPerNode, bits, maskPerNode) + nodeIp, subnet, err := computeSubnet(ip, int64(i), maskPerNode, ones, bits) if err != nil { return err } @@ -181,24 +198,35 @@ func (t *T) allocateSubnets() error { return nil } -func computeSubnet(baseIP net.IP, nodeIndex int64, maskPerNode int, bits, subnetOnes int) (net.IP, string, error) { +func computeSubnet(baseIP net.IP, nodeIndex int64, maskPerNode int, ones, bits int) (net.IP, string, error) { ip16 := baseIP.To16() if ip16 == nil { return nil, "", fmt.Errorf("invalid base ip %s", baseIP) } - ipsPerNode := new(big.Int).Lsh(big.NewInt(1), uint(maskPerNode)) + if maskPerNode > bits || maskPerNode < 0 { + return nil, "", fmt.Errorf("maskPerNode /%d out of bounds for %d-bit space", maskPerNode, bits) + } + hostBits := bits - maskPerNode + ipsPerNode := new(big.Int).Lsh(big.NewInt(1), uint(hostBits)) + // Compute the offset block: nodeIndex * ipsPerNode baseInt := new(big.Int).SetBytes(ip16) idxBig := big.NewInt(nodeIndex) offset := new(big.Int).Mul(idxBig, ipsPerNode) + // Add the offset to the base address nodeInt := new(big.Int).Add(baseInt, offset) - if nodeInt.BitLen() > 128 { - return nil, "", fmt.Errorf("computed ip exceeds maximum size") + parentHostBits := bits - ones + parentSize := new(big.Int).Lsh(big.NewInt(1), uint(parentHostBits)) + parentCeiling := new(big.Int).Add(baseInt, parentSize) + + if nodeInt.Cmp(parentCeiling) >= 0 { + return nil, "", fmt.Errorf("computed subnet index %d overflows the parent network boundary", nodeIndex) } + // Unpack bytes back to net.IP nodeBytes := nodeInt.FillBytes(make([]byte, 16)) nodeIP := net.IP(nodeBytes) @@ -206,21 +234,44 @@ func computeSubnet(baseIP net.IP, nodeIndex int64, maskPerNode int, bits, subnet nodeIP = nodeIP.To4() } - prefix := bits - subnetOnes - subnet := fmt.Sprintf("%s/%d", nodeIP.String(), prefix) + subnet := fmt.Sprintf("%s/%d", nodeIP.String(), maskPerNode) + return nodeIP, subnet, nil } func (t *T) checkMaxIpsPerNode(network *net.IPNet, maskPerNode int, nodes []string) error { - ipsPerNode := new(big.Int).Lsh(big.NewInt(1), uint(maskPerNode)) - one := big.NewInt(1) + if network == nil || network.Mask == nil { + return fmt.Errorf("invalid network context provided") + } + + numNodes := int64(len(nodes)) + if numNodes == 0 { + // Nothing to distribute + return nil + } + ones, bits := network.Mask.Size() + + if maskPerNode < ones || maskPerNode > bits { + return fmt.Errorf("requested node mask /%d is out of bounds for parent network %s", maskPerNode, network) + } + + one := big.NewInt(1) + maxIPs := new(big.Int).Lsh(one, uint(bits-ones)) - maxIPsPerNodes := new(big.Int).Div(maxIPs, big.NewInt(int64(len(nodes)))) - minSubnetOnes := maxIPsPerNodes.BitLen() - 1 - maxIPsPerNodes = new(big.Int).Lsh(one, uint(minSubnetOnes)) - if ipsPerNode.Cmp(maxIPsPerNodes) > 0 { - return fmt.Errorf("ips_per_node=%s must be <=%s (%s has %s ips to distribute to %d nodes)", ipsPerNode.String(), maxIPsPerNodes.String(), network, maxIPs.String(), len(nodes)) + requestedIPsPerNode := new(big.Int).Lsh(one, uint(bits-maskPerNode)) + totalRequiredIPs := new(big.Int).Mul(requestedIPsPerNode, big.NewInt(numNodes)) + if totalRequiredIPs.Cmp(maxIPs) > 0 { + maxIPsPerNodePossible := new(big.Int).Div(maxIPs, big.NewInt(numNodes)) + return fmt.Errorf("ips_per_node=%s (/%d) is too large. Total required across %d nodes is %s, but %s only provides %s total IPs (max possible per node is ~%s)", + requestedIPsPerNode.String(), + maskPerNode, + numNodes, + totalRequiredIPs.String(), + network.String(), + maxIPs.String(), + maxIPsPerNodePossible.String(), + ) } return nil } From 300e18871ca9b1f08cbe011e0b449bc1b6882f14 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 08:59:13 +0200 Subject: [PATCH 13/32] Switch to local-by-default "om resource ls" Use --node to show a multi-node dataset, instead of multi-node by default. The ox command will stay multi-node by default, as we don't know which node to focus on if not explicited by the user. --- core/omcmd/object_resource_list.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/core/omcmd/object_resource_list.go b/core/omcmd/object_resource_list.go index afae55737..b95357e0c 100644 --- a/core/omcmd/object_resource_list.go +++ b/core/omcmd/object_resource_list.go @@ -9,6 +9,7 @@ import ( "github.com/opensvc/om3/v3/core/output" "github.com/opensvc/om3/v3/core/rawconfig" "github.com/opensvc/om3/v3/daemon/api" + "github.com/opensvc/om3/v3/util/hostname" ) type ( @@ -33,6 +34,10 @@ func (t *CmdObjectResourceList) Run(kind string) error { params := api.GetResourcesParams{Path: &mergedSelector} if t.NodeSelector != "" { params.Node = &t.NodeSelector + } else { + // Default to local node for om command + localNode := hostname.Hostname() + params.Node = &localNode } if t.RID != "" { params.Resource = &t.RID From 5a76a5293bd53afe5aaaf7126a461d8847ba3025 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 11:29:00 +0200 Subject: [PATCH 14/32] Avoid queueing a status refresh on ip/fs evt if a action is in progress In this case the status refresh will happen at the end of the action already. --- daemon/imon/main_cmd.go | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/daemon/imon/main_cmd.go b/daemon/imon/main_cmd.go index 571ab4aef..b4055a24c 100644 --- a/daemon/imon/main_cmd.go +++ b/daemon/imon/main_cmd.go @@ -1338,6 +1338,9 @@ func (t *Manager) onNetIPAddrAdded(c *msgbus.NetIPAddrAdded) { if c.Node != t.localhost { return } + if !t.canRefreshOnEvent() { + return + } ip := extractIP(c.Address) t.checkResourceForIPMatch(ip, c.LinkName, "added") @@ -1351,6 +1354,9 @@ func (t *Manager) onNetIPAddrDeleted(c *msgbus.NetIPAddrDeleted) { if c.Node != t.localhost { return } + if !t.canRefreshOnEvent() { + return + } ip := extractIP(c.Address) t.checkResourceForIPMatch(ip, c.LinkName, "deleted") @@ -1392,10 +1398,13 @@ func (t *Manager) checkResourceForMountMatch(mountPoint string, fsType string, e // It checks if any instance resource has a matching mount point in its info, // and if so, triggers a status refresh to update the resource status. func (t *Manager) onFSMounted(c *msgbus.FSMounted) { - // Only handle events for the localhost + // Only handlgoinge events for the localhost if c.Node != t.localhost { return } + if !t.canRefreshOnEvent() { + return + } t.checkResourceForMountMatch(c.MountPoint, c.FSType, "mounted") } @@ -1407,6 +1416,9 @@ func (t *Manager) onFSUmounted(c *msgbus.FSUmounted) { if c.Node != t.localhost { return } + if !t.canRefreshOnEvent() { + return + } t.checkResourceForMountMatch(c.MountPoint, c.FSType, "unmounted") } @@ -1418,5 +1430,12 @@ func (t *Manager) onFSRemounted(c *msgbus.FSRemounted) { if c.Node != t.localhost { return } + if !t.canRefreshOnEvent() { + return + } t.checkResourceForMountMatch(c.MountPoint, c.FSType, "remounted") } + +func (t *Manager) canRefreshOnEvent() bool { + return !t.state.State.IsDoing() +} From 4d35a28aa8ef51f1e2eac15f716c21f295c0ec69 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 14:59:32 +0200 Subject: [PATCH 15/32] Move the "instance resource info list|push" commands To "resource info list|push". We already have the "resource list" command in the "resource" command tree, and every resource action is clearly node-scoped. --- core/commoncmd/object.go | 20 +++----------------- core/om/factory.go | 4 ++-- core/om/kind_all.go | 15 ++++++--------- core/om/kind_svc.go | 15 ++++++--------- core/om/kind_vol.go | 14 +++++--------- core/ox/factory.go | 4 ++-- core/ox/kind_all.go | 15 ++++++--------- core/ox/kind_svc.go | 15 ++++++--------- core/ox/kind_vol.go | 15 ++++++--------- 9 files changed, 42 insertions(+), 75 deletions(-) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index f788f4267..9ce3f5191 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -107,23 +107,9 @@ func NewCmdObjectResource(kind string) *cobra.Command { } } -func NewCmdObjectInstanceResource(kind string) *cobra.Command { - cmd := &cobra.Command{ - GroupID: GroupIDSubsystems, - Use: "resource", - Short: "query, push instance resources", - Aliases: []string{"res"}, - } - cmd.AddGroup( - NewGroupSubsystems(), - ) - return cmd -} - -func NewCmdObjectInstanceResourceInfo(kind string) *cobra.Command { +func NewCmdObjectResourceInfo(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, - Use: "info", - Short: "list, push the key-values reported by resources", + Use: "info", + Short: "list, push the key-values reported by resources", } } diff --git a/core/om/factory.go b/core/om/factory.go index 83144bd2c..b1b154e85 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2902,7 +2902,7 @@ func newCmdObjectInstanceSyncUpdate(kind string) *cobra.Command { return cmd } -func newCmdObjectInstanceResourceInfoList(kind string) *cobra.Command { +func newCmdObjectResourceInfoList(kind string) *cobra.Command { var options commands.CmdObjectInstanceResourceInfoList cmd := &cobra.Command{ Use: "list", @@ -2918,7 +2918,7 @@ func newCmdObjectInstanceResourceInfoList(kind string) *cobra.Command { return cmd } -func newCmdObjectInstanceResourceInfoPush(kind string) *cobra.Command { +func newCmdObjectResourceInfoPush(kind string) *cobra.Command { var options commands.CmdObjectInstanceResourceInfoPush cmd := &cobra.Command{ Use: "push", diff --git a/core/om/kind_all.go b/core/om/kind_all.go index 78cf0d072..1096f45d2 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -22,8 +22,6 @@ func init() { cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) - cmdObjectInstanceResource := commoncmd.NewCmdObjectInstanceResource(kind) - cmdObjectInstanceResourceInfo := commoncmd.NewCmdObjectInstanceResourceInfo(kind) cmdObjectInstanceSync := commoncmd.NewCmdObjectInstanceSync(kind) cmdObjectPG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectPG.Hidden = true @@ -31,6 +29,7 @@ func init() { cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) cmdObjectPush := newCmdObjectPush(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) + cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectSchedule := commoncmd.NewCmdObjectSchedule(kind) cmdObjectSync := commoncmd.NewCmdObjectSync(kind) @@ -95,7 +94,6 @@ func init() { cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, cmdObjectInstanceSync, - cmdObjectInstanceResource, newCmdObjectInstanceBoot(kind), newCmdObjectInstanceDelete(kind), newCmdObjectInstanceFreeze(kind), @@ -120,12 +118,10 @@ func init() { cmdObjectInstancePG.AddCommand( newCmdObjectInstancePGUpdate(kind), ) - cmdObjectInstanceResource.AddCommand( - cmdObjectInstanceResourceInfo, - ) - cmdObjectInstanceResourceInfo.AddCommand( - newCmdObjectInstanceResourceInfoList(kind), - newCmdObjectInstanceResourceInfoPush(kind), + + cmdObjectResourceInfo.AddCommand( + newCmdObjectResourceInfoList(kind), + newCmdObjectResourceInfoPush(kind), ) cmdObjectInstanceSync.AddCommand( newCmdObjectInstanceSyncIngest(kind), @@ -139,6 +135,7 @@ func init() { ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), + cmdObjectResourceInfo, ) cmdObjectConfig.AddCommand( omcmd.NewCmdObjectConfigDoc(kind), diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index d8c673626..ee3c21814 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -24,14 +24,13 @@ func init() { cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectInstanceSync := commoncmd.NewCmdObjectInstanceSync(kind) - cmdObjectInstanceResource := commoncmd.NewCmdObjectInstanceResource(kind) - cmdObjectInstanceResourceInfo := commoncmd.NewCmdObjectInstanceResourceInfo(kind) cmdObjectPG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectPG.Hidden = true cmdObjectPrint := newCmdObjectPrint(kind) cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) cmdObjectPush := newCmdObjectPush(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) + cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectSchedule := commoncmd.NewCmdObjectSchedule(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectSync := commoncmd.NewCmdObjectSync(kind) @@ -115,12 +114,12 @@ func init() { ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), + cmdObjectResourceInfo, ) cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, cmdObjectInstancePG, cmdObjectInstanceSync, - cmdObjectInstanceResource, newCmdObjectInstanceBoot(kind), newCmdObjectInstanceDelete(kind), newCmdObjectInstanceFreeze(kind), @@ -145,12 +144,10 @@ func init() { cmdObjectInstancePG.AddCommand( newCmdObjectInstancePGUpdate(kind), ) - cmdObjectInstanceResource.AddCommand( - cmdObjectInstanceResourceInfo, - ) - cmdObjectInstanceResourceInfo.AddCommand( - newCmdObjectInstanceResourceInfoList(kind), - newCmdObjectInstanceResourceInfoPush(kind), + + cmdObjectResourceInfo.AddCommand( + newCmdObjectResourceInfoList(kind), + newCmdObjectResourceInfoPush(kind), ) cmdObjectInstanceSync.AddCommand( newCmdObjectInstanceSyncFull(kind), diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index e694c7f81..92f6b061b 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -17,8 +17,6 @@ func init() { cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) - cmdObjectInstanceResource := commoncmd.NewCmdObjectInstanceResource(kind) - cmdObjectInstanceResourceInfo := commoncmd.NewCmdObjectInstanceResourceInfo(kind) cmdObjectInstanceSync := commoncmd.NewCmdObjectInstanceSync(kind) cmdObjectPG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectPG.Hidden = true @@ -26,6 +24,7 @@ func init() { cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) cmdObjectPush := newCmdObjectPush(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) + cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectSchedule := commoncmd.NewCmdObjectSchedule(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectSync := commoncmd.NewCmdObjectSync(kind) @@ -108,7 +107,6 @@ func init() { cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, cmdObjectInstancePG, - cmdObjectInstanceResource, cmdObjectInstanceSync, newCmdObjectInstanceBoot(kind), newCmdObjectInstanceDelete(kind), @@ -143,13 +141,11 @@ func init() { ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), + cmdObjectResourceInfo, ) - cmdObjectInstanceResource.AddCommand( - cmdObjectInstanceResourceInfo, - ) - cmdObjectInstanceResourceInfo.AddCommand( - newCmdObjectInstanceResourceInfoList(kind), - newCmdObjectInstanceResourceInfoPush(kind), + cmdObjectResourceInfo.AddCommand( + newCmdObjectResourceInfoList(kind), + newCmdObjectResourceInfoPush(kind), ) cmdObjectPG.AddCommand( newCmdObjectInstancePGUpdate(kind), diff --git a/core/ox/factory.go b/core/ox/factory.go index 9403eef82..11deade66 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -2684,7 +2684,7 @@ func newCmdObjectInstanceSyncUpdate(kind string) *cobra.Command { return cmd } -func newCmdObjectInstanceResourceInfoList(kind string) *cobra.Command { +func newCmdObjectResourceInfoList(kind string) *cobra.Command { var options commands.CmdObjectInstanceResourceInfoList cmd := &cobra.Command{ Use: "list", @@ -2700,7 +2700,7 @@ func newCmdObjectInstanceResourceInfoList(kind string) *cobra.Command { return cmd } -func newCmdObjectInstanceResourceInfoPush(kind string) *cobra.Command { +func newCmdObjectResourceInfoPush(kind string) *cobra.Command { var options commands.CmdObjectInstanceResourceInfoPush cmd := &cobra.Command{ Use: "push", diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index 4bb64875a..e4b9821ba 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -16,10 +16,8 @@ func init() { cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) - cmdObjectInstanceResource := commoncmd.NewCmdObjectInstanceResource(kind) cmdObjectPG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectPG.Hidden = true - cmdObjectInstanceResourceInfo := commoncmd.NewCmdObjectInstanceResourceInfo(kind) cmdObjectInstanceSync := commoncmd.NewCmdObjectInstanceSync(kind) cmdObjectSchedule := newCmdObjectSchedule(kind) cmdObjectSet := newCmdObjectSet(kind) @@ -28,6 +26,7 @@ func init() { cmdObjectPrint := newCmdObjectPrint(kind) cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) + cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectPush := newCmdObjectPush(kind) cmdObjectValidate := newCmdObjectValidate(kind) @@ -92,7 +91,6 @@ func init() { cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, cmdObjectInstancePG, - cmdObjectInstanceResource, cmdObjectInstanceSync, newCmdObjectInstanceBoot(kind), newCmdObjectInstanceDelete(kind), @@ -118,12 +116,10 @@ func init() { cmdObjectInstancePG.AddCommand( newCmdObjectInstancePGUpdate(kind), ) - cmdObjectInstanceResource.AddCommand( - cmdObjectInstanceResourceInfo, - ) - cmdObjectInstanceResourceInfo.AddCommand( - newCmdObjectInstanceResourceInfoList(kind), - newCmdObjectInstanceResourceInfoPush(kind), + + cmdObjectResourceInfo.AddCommand( + newCmdObjectResourceInfoList(kind), + newCmdObjectResourceInfoPush(kind), ) cmdObjectInstanceSync.AddCommand( newCmdObjectInstanceSyncIngest(kind), @@ -134,6 +130,7 @@ func init() { ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), + cmdObjectResourceInfo, ) cmdObjectConfig.AddCommand( commoncmd.NewCmdObjectConfigDoc(kind), diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 286ba9743..2e8a9e4c2 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -19,13 +19,12 @@ func init() { cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) - cmdObjectInstanceResource := commoncmd.NewCmdObjectInstanceResource(kind) cmdObjectPG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectPG.Hidden = true - cmdObjectInstanceResourceInfo := commoncmd.NewCmdObjectInstanceResourceInfo(kind) cmdObjectInstanceSync := commoncmd.NewCmdObjectInstanceSync(kind) cmdObjectSchedule := newCmdObjectSchedule(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) + cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectPrint := newCmdObjectPrint(kind) cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) @@ -106,11 +105,11 @@ func init() { ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), + cmdObjectResourceInfo, ) cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, cmdObjectInstancePG, - cmdObjectInstanceResource, cmdObjectInstanceSync, newCmdObjectInstanceBoot(kind), newCmdObjectInstanceDelete(kind), @@ -136,12 +135,10 @@ func init() { cmdObjectInstancePG.AddCommand( newCmdObjectInstancePGUpdate(kind), ) - cmdObjectInstanceResource.AddCommand( - cmdObjectInstanceResourceInfo, - ) - cmdObjectInstanceResourceInfo.AddCommand( - newCmdObjectInstanceResourceInfoList(kind), - newCmdObjectInstanceResourceInfoPush(kind), + + cmdObjectResourceInfo.AddCommand( + newCmdObjectResourceInfoList(kind), + newCmdObjectResourceInfoPush(kind), ) cmdObjectInstanceSync.AddCommand( newCmdObjectInstanceSyncIngest(kind), diff --git a/core/ox/kind_vol.go b/core/ox/kind_vol.go index 2432a5938..1bfc31120 100644 --- a/core/ox/kind_vol.go +++ b/core/ox/kind_vol.go @@ -13,10 +13,8 @@ func init() { cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) - cmdObjectInstanceResource := commoncmd.NewCmdObjectInstanceResource(kind) cmdObjectPG := commoncmd.NewCmdObjectInstancePG(kind) cmdObjectPG.Hidden = true - cmdObjectInstanceResourceInfo := commoncmd.NewCmdObjectInstanceResourceInfo(kind) cmdObjectInstanceSync := commoncmd.NewCmdObjectInstanceSync(kind) cmdObjectSchedule := newCmdObjectSchedule(kind) cmdObjectSet := newCmdObjectSet(kind) @@ -24,6 +22,7 @@ func init() { cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) cmdObjectPush := newCmdObjectPush(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) + cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectValidate := newCmdObjectValidate(kind) root.AddCommand( @@ -100,7 +99,6 @@ func init() { cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, cmdObjectInstancePG, - cmdObjectInstanceResource, cmdObjectInstanceSync, newCmdObjectInstanceBoot(kind), newCmdObjectInstanceDelete(kind), @@ -126,12 +124,10 @@ func init() { cmdObjectInstancePG.AddCommand( newCmdObjectInstancePGUpdate(kind), ) - cmdObjectInstanceResource.AddCommand( - cmdObjectInstanceResourceInfo, - ) - cmdObjectInstanceResourceInfo.AddCommand( - newCmdObjectInstanceResourceInfoList(kind), - newCmdObjectInstanceResourceInfoPush(kind), + + cmdObjectResourceInfo.AddCommand( + newCmdObjectResourceInfoList(kind), + newCmdObjectResourceInfoPush(kind), ) cmdObjectInstanceSync.AddCommand( newCmdObjectInstanceSyncIngest(kind), @@ -142,6 +138,7 @@ func init() { ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), + cmdObjectResourceInfo, ) cmdObjectSchedule.AddCommand( newCmdObjectScheduleList(kind), From 183f916a272adccd7aa727be639da96d25f73130 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 15:30:01 +0200 Subject: [PATCH 16/32] Support the "om svc1 container enter zzz" command As a synomym for "om svc1 container enter --rid container#zzz". The late syntax being longer to type and stuttering, it was getting annoying. --- core/object/actor_enter.go | 2 +- core/om/factory.go | 21 +++++++++++++++++--- core/ox/factory.go | 40 ++++++++++++++++++++++++++------------ 3 files changed, 47 insertions(+), 16 deletions(-) diff --git a/core/object/actor_enter.go b/core/object/actor_enter.go index 2a86378af..8e673ccc5 100644 --- a/core/object/actor_enter.go +++ b/core/object/actor_enter.go @@ -19,7 +19,7 @@ func (t *actor) Enter(ctx context.Context, rid string) error { if i, ok := r.(enterer); !ok { continue } else if container != nil { - return fmt.Errorf("multiple resources support enter. use the --rid option") + return fmt.Errorf("multiple resources support enter. specify a container id") } else { container = i rid = r.RID() diff --git a/core/om/factory.go b/core/om/factory.go index b1b154e85..6b8af3ed0 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2117,10 +2117,14 @@ func newCmdObjectEnable(kind string) *cobra.Command { func newCmdObjectContainerEnter(kind string) *cobra.Command { var options commands.CmdObjectContainerEnter cmd := &cobra.Command{ - Use: "enter", + Use: "enter [ID]", Short: "open a shell in a container resource", - Long: "Enter any container resource if --rid is not set.", + Long: "Enter any container resource. Specify a container ID as a positional argument or let om select the container if unambiguous.", + Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } return options.Run(kind) }, } @@ -3649,7 +3653,18 @@ func newCmdObjectRun(kind string) *cobra.Command { } func newCmdObjectEnter(kind string) *cobra.Command { - cmd := newCmdObjectContainerEnter(kind) + var options commands.CmdObjectContainerEnter + cmd := &cobra.Command{ + Use: "enter", + Short: "open a shell in a container resource", + Long: "Enter any container resource. Use --rid to specify which container to enter.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagObject(flags, &options.ObjectSelector) + commoncmd.FlagRIDWithCompletion(cmd, &options.RID) cmd.Hidden = true return cmd } diff --git a/core/ox/factory.go b/core/ox/factory.go index 11deade66..46bfec5bb 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1077,8 +1077,8 @@ func newCmdNodeSystemUser() *cobra.Command { func newCmdNodeConfigEdit() *cobra.Command { var options commands.CmdNodeConfigEdit cmd := &cobra.Command{ - Use: "edit", - Short: "edit the node configuration", + Use: "edit", + Short: "edit the node configuration", Aliases: []string{"ed"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run() @@ -1849,8 +1849,8 @@ func newCmdObjectComplianceEnv(kind string) *cobra.Command { func newCmdObjectComplianceListModules(kind string) *cobra.Command { var options commands.CmdObjectComplianceListModules cmd := &cobra.Command{ - Use: "modules", - Short: "list modules available on this object", + Use: "modules", + Short: "list modules available on this object", Aliases: []string{"mod"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) @@ -1864,8 +1864,8 @@ func newCmdObjectComplianceListModules(kind string) *cobra.Command { func newCmdObjectComplianceListModuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceListModuleset cmd := &cobra.Command{ - Use: "moduleset", - Short: "list modulesets available to this object", + Use: "moduleset", + Short: "list modulesets available to this object", Aliases: []string{"modulesets", "modset"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) @@ -1880,8 +1880,8 @@ func newCmdObjectComplianceListModuleset(kind string) *cobra.Command { func newCmdObjectComplianceListRuleset(kind string) *cobra.Command { var options commands.CmdObjectComplianceListRuleset cmd := &cobra.Command{ - Use: "ruleset", - Short: "list rulesets available to this object", + Use: "ruleset", + Short: "list rulesets available to this object", Aliases: []string{"rulesets"}, RunE: func(cmd *cobra.Command, args []string) error { return options.Run(kind) @@ -2052,10 +2052,14 @@ func newCmdObjectEnable(kind string) *cobra.Command { func newCmdObjectContainerEnter(kind string) *cobra.Command { var options commands.CmdObjectContainerEnter cmd := &cobra.Command{ - Use: "enter", + Use: "enter [ID]", Short: "open a shell in a container resource", - Long: "Enter any container resource if --rid is not set.", + Long: "Enter any container resource. Specify a container ID as a positional argument or let om select the container if unambiguous.", + Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } return options.Run(kind) }, } @@ -2450,7 +2454,7 @@ func newCmdObjectInstancePGUpdate(kind string) *cobra.Command { func newCmdObjectInstanceStatus(kind string) *cobra.Command { var options commands.CmdObjectInstanceStatus cmd := &cobra.Command{ - Use: "status", + Use: "status", Aliases: []string{"stat"}, Short: "print the object instances status", Long: `Resources Flags: @@ -3708,7 +3712,19 @@ func NewCmdContextShow() *cobra.Command { } func newCmdObjectEnter(kind string) *cobra.Command { - cmd := newCmdObjectContainerEnter(kind) + var options commands.CmdObjectContainerEnter + cmd := &cobra.Command{ + Use: "enter", + Short: "open a shell in a container resource", + Long: "Enter any container resource. Use --rid to specify which container to enter.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagObject(flags, &options.ObjectSelector) + commoncmd.FlagRIDWithCompletion(cmd, &options.RID) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) cmd.Hidden = true return cmd } From 2029679ad27e52a79c4d7bf355793f2fb4cc7013 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 16:18:09 +0200 Subject: [PATCH 17/32] Support the "om svc1 container logs zzz" command As a synomym for "om svc1 container logs --rid container#zzz". The late syntax being longer to type and stuttering, it was getting annoying. --- core/object/actor_container_logs.go | 4 ++-- core/om/factory.go | 7 ++++++- core/ox/factory.go | 7 ++++++- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/core/object/actor_container_logs.go b/core/object/actor_container_logs.go index 508d0e6eb..e61068eb9 100644 --- a/core/object/actor_container_logs.go +++ b/core/object/actor_container_logs.go @@ -20,7 +20,7 @@ func (t *actor) ContainerLogs(ctx context.Context, rid string, follow bool, line if i, ok := r.(containerLogger); !ok { continue } else if container != nil { - return fmt.Errorf("multiple resources support container logs. use the --rid option") + return fmt.Errorf("multiple resources support container logs. specify a container id") } else { container = i rid = r.RID() @@ -51,7 +51,7 @@ func (t *actor) ContainerLogsStream(ctx context.Context, rid string, follow bool if i, ok := r.(containerLogger); !ok { continue } else if container != nil { - return nil, fmt.Errorf("multiple resources support container logs. use the --rid option") + return nil, fmt.Errorf("multiple resources support container logs. specify a container id") } else { container = i rid = r.RID() diff --git a/core/om/factory.go b/core/om/factory.go index 6b8af3ed0..bd655647a 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2137,10 +2137,15 @@ func newCmdObjectContainerEnter(kind string) *cobra.Command { func newCmdObjectContainerLogs(kind string) *cobra.Command { var options commands.CmdObjectContainerLogs cmd := &cobra.Command{ - Use: "logs", + Use: "logs [ID]", Aliases: []string{"log"}, Short: "show container logs", + Long: "Show container logs. Specify a container ID as a positional argument or let om select the container if unambiguous.", + Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } return options.Run(kind) }, } diff --git a/core/ox/factory.go b/core/ox/factory.go index 46bfec5bb..e8d672d14 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1928,10 +1928,15 @@ func newCmdObjectComplianceShowRuleset(kind string) *cobra.Command { func newCmdObjectContainerLogs(kind string) *cobra.Command { var options commands.CmdObjectContainerLogs cmd := &cobra.Command{ - Use: "logs", + Use: "logs [ID]", Aliases: []string{"log"}, Short: "show container logs", + Long: "Show container logs. Specify a container ID as a positional argument or let om select the container if unambiguous.", + Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } return options.Run(kind) }, } From f89ab5da01f4e6e6d4f5fa7578307c99c6c48e49 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 16:37:54 +0200 Subject: [PATCH 18/32] Add the "om container ls" command As a synomym of "om resource ls --rid container". --- core/om/factory.go | 18 ++++++++++++++++++ core/om/kind_all.go | 1 + core/om/kind_svc.go | 1 + core/ox/factory.go | 18 ++++++++++++++++++ core/ox/kind_all.go | 1 + core/ox/kind_svc.go | 1 + 6 files changed, 40 insertions(+) diff --git a/core/om/factory.go b/core/om/factory.go index bd655647a..039b2cbbc 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2157,6 +2157,24 @@ func newCmdObjectContainerLogs(kind string) *cobra.Command { return cmd } +func newCmdObjectContainerList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "container" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list container resources", + Long: "List container resources. Equivalent to 'resource ls --rid container'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectConfigEval(kind string) *cobra.Command { var options commands.CmdObjectConfigGet cmd := &cobra.Command{ diff --git a/core/om/kind_all.go b/core/om/kind_all.go index 1096f45d2..a7c654d5f 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -150,6 +150,7 @@ func init() { cmdObjectContainer.AddCommand( newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), + newCmdObjectContainerList(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index ee3c21814..d56d343ed 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -105,6 +105,7 @@ func init() { cmdObjectContainer.AddCommand( newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), + newCmdObjectContainerList(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), diff --git a/core/ox/factory.go b/core/ox/factory.go index e8d672d14..1447e1492 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1949,6 +1949,24 @@ func newCmdObjectContainerLogs(kind string) *cobra.Command { return cmd } +func newCmdObjectContainerList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "container" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list container resources", + Long: "List container resources. Equivalent to 'resource ls --rid container'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectCreate(kind string) *cobra.Command { var options commands.CmdObjectCreate cmd := &cobra.Command{ diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index e4b9821ba..1841fa002 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -144,6 +144,7 @@ func init() { cmdObjectContainer.AddCommand( newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), + newCmdObjectContainerList(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 2e8a9e4c2..b3c30f718 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -96,6 +96,7 @@ func init() { cmdObjectContainer.AddCommand( newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), + newCmdObjectContainerList(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), From 47a1440c9bd95af84c0f9f6cb40005853f6b93ec Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 16:57:48 +0200 Subject: [PATCH 19/32] Add the "om svc task ls" command As a synomym of "om svc resource ls --rid task". --- core/commoncmd/object.go | 8 ++++++++ core/om/factory.go | 18 ++++++++++++++++++ core/om/kind_all.go | 5 +++++ core/om/kind_svc.go | 5 +++++ core/ox/factory.go | 18 ++++++++++++++++++ core/ox/kind_all.go | 5 +++++ core/ox/kind_svc.go | 5 +++++ 7 files changed, 64 insertions(+) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 9ce3f5191..c42b7c422 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -38,6 +38,14 @@ func NewCmdObjectContainer(kind string) *cobra.Command { } } +func NewCmdObjectTask(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "task", + Short: "list tasks", + } +} + func NewCmdObjectInstance(kind string) *cobra.Command { cmd := &cobra.Command{ GroupID: GroupIDSubsystems, diff --git a/core/om/factory.go b/core/om/factory.go index 039b2cbbc..2dc0d38a6 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2175,6 +2175,24 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectTaskList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "task" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list task resources", + Long: "List task resources. Equivalent to 'resource ls --rid task'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectConfigEval(kind string) *cobra.Command { var options commands.CmdObjectConfigGet cmd := &cobra.Command{ diff --git a/core/om/kind_all.go b/core/om/kind_all.go index a7c654d5f..0590d8210 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -18,6 +18,7 @@ func init() { cmdObjectComplianceList := newCmdObjectComplianceList(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) @@ -48,6 +49,7 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectTask, cmdObjectEdit, cmdObjectInstance, cmdObjectPG, @@ -152,6 +154,9 @@ func init() { newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), ) + cmdObjectTask.AddCommand( + newCmdObjectTaskList(kind), + ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), ) diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index d56d343ed..7edfd2632 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -19,6 +19,7 @@ func init() { cmdObjectComplianceList := newCmdObjectComplianceList(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) @@ -49,6 +50,7 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectTask, cmdObjectEdit, cmdObjectInstance, cmdObjectPG, @@ -107,6 +109,9 @@ func init() { newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), ) + cmdObjectTask.AddCommand( + newCmdObjectTaskList(kind), + ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), ) diff --git a/core/ox/factory.go b/core/ox/factory.go index 1447e1492..9a85689e0 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1967,6 +1967,24 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectTaskList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "task" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list task resources", + Long: "List task resources. Equivalent to 'resource ls --rid task'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectCreate(kind string) *cobra.Command { var options commands.CmdObjectCreate cmd := &cobra.Command{ diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index 1841fa002..629405726 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -23,6 +23,7 @@ func init() { cmdObjectSet := newCmdObjectSet(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectPrint := newCmdObjectPrint(kind) cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) @@ -43,6 +44,7 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectTask, cmdObjectEdit, cmdObjectInstance, cmdObjectPG, @@ -146,6 +148,9 @@ func init() { newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), ) + cmdObjectTask.AddCommand( + newCmdObjectTaskList(kind), + ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), ) diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index b3c30f718..ceb3d9466 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -15,6 +15,7 @@ func init() { cmdObjectComplianceList := newCmdObjectComplianceList(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) @@ -44,6 +45,7 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectTask, cmdObjectEdit, cmdObjectInstance, cmdObjectPG, @@ -98,6 +100,9 @@ func init() { newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), ) + cmdObjectTask.AddCommand( + newCmdObjectTaskList(kind), + ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), ) From 9d1c1f0dde1580c8af9c2cf6c0efbeb70fb54b43 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 17:13:55 +0200 Subject: [PATCH 20/32] Add the "om svc task run " command As a synonym of "om svc instance run --rid task#". --- core/commoncmd/object.go | 2 +- core/om/factory.go | 30 ++++++++++++++++++++++++++++++ core/om/kind_all.go | 1 + core/om/kind_svc.go | 1 + core/ox/factory.go | 28 ++++++++++++++++++++++++++++ core/ox/kind_all.go | 1 + core/ox/kind_svc.go | 1 + 7 files changed, 63 insertions(+), 1 deletion(-) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index c42b7c422..1f7446e8a 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -42,7 +42,7 @@ func NewCmdObjectTask(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, Use: "task", - Short: "list tasks", + Short: "list, run tasks", } } diff --git a/core/om/factory.go b/core/om/factory.go index 2dc0d38a6..4a3139d74 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2175,6 +2175,36 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectTaskRun(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRun + cmd := &cobra.Command{ + Use: "run [ID]", + Short: "execute a task resource", + Long: "Execute a task resource. Specify a task ID as a positional argument or let om select the task if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "task#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagConfirm(flags, &options.Confirm) + commoncmd.FlagCron(flags, &options.Cron) + commoncmd.FlagEnv(flags, &options.Env) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectTaskList(kind string) *cobra.Command { var options commands.CmdObjectResourceList options.RID = "task" diff --git a/core/om/kind_all.go b/core/om/kind_all.go index 0590d8210..726f3a7a7 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -156,6 +156,7 @@ func init() { ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), + newCmdObjectTaskRun(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index 7edfd2632..c2812c2bd 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -111,6 +111,7 @@ func init() { ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), + newCmdObjectTaskRun(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), diff --git a/core/ox/factory.go b/core/ox/factory.go index 9a85689e0..69b924237 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1967,6 +1967,34 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectTaskRun(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRun + cmd := &cobra.Command{ + Use: "run [ID]", + Short: "execute a task resource", + Long: "Execute a task resource. Specify a task ID as a positional argument or let om select the task if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "task#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagConfirm(flags, &options.Confirm) + commoncmd.FlagCron(flags, &options.Cron) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagEnv(flags, &options.Env) + return cmd +} + func newCmdObjectTaskList(kind string) *cobra.Command { var options commands.CmdObjectResourceList options.RID = "task" diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index 629405726..592f9eb0c 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -150,6 +150,7 @@ func init() { ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), + newCmdObjectTaskRun(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index ceb3d9466..4f5592d64 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -102,6 +102,7 @@ func init() { ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), + newCmdObjectTaskRun(kind), ) cmdObjectEdit.AddCommand( newCmdObjectEditConfig(kind), From 39c775273e4b802ba1f934cd675bbd30e962e1d9 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 17:40:43 +0200 Subject: [PATCH 21/32] Add the "om svc sync ls" command As a synonym of "om svc resource ls --rid sync". --- core/commoncmd/object.go | 1 + core/om/factory.go | 18 ++++++++++++++++++ core/om/kind_all.go | 1 + core/om/kind_svc.go | 1 + core/om/kind_vol.go | 1 + core/ox/factory.go | 18 ++++++++++++++++++ core/ox/kind_all.go | 5 +++++ core/ox/kind_svc.go | 5 +++++ 8 files changed, 50 insertions(+) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 1f7446e8a..72f206f13 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -93,6 +93,7 @@ func NewCmdObjectSync(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, Use: "sync", + Short: "replicate data, list sync resources", Hidden: true, Aliases: []string{"syn", "sy"}, } diff --git a/core/om/factory.go b/core/om/factory.go index 4a3139d74..bfb99ab02 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2205,6 +2205,24 @@ func newCmdObjectTaskRun(kind string) *cobra.Command { return cmd } +func newCmdObjectSyncList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "sync" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list sync resources", + Long: "List sync resources. Equivalent to 'resource ls --rid sync'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectTaskList(kind string) *cobra.Command { var options commands.CmdObjectResourceList options.RID = "task" diff --git a/core/om/kind_all.go b/core/om/kind_all.go index 726f3a7a7..80ff095fd 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -187,6 +187,7 @@ func init() { newCmdObjectInstanceSyncResync(kind), newCmdObjectInstanceSyncSplit(kind), newCmdObjectInstanceSyncUpdate(kind), + newCmdObjectSyncList(kind), ) cmdObjectValidate.AddCommand( newCmdObjectValidateConfig(kind), diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index c2812c2bd..d03c4f435 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -189,6 +189,7 @@ func init() { newCmdObjectInstanceSyncResync(kind), newCmdObjectInstanceSyncSplit(kind), newCmdObjectInstanceSyncUpdate(kind), + newCmdObjectSyncList(kind), ) cmdObjectValidate.AddCommand( newCmdObjectValidateConfig(kind), diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index 92f6b061b..27c3410a8 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -176,6 +176,7 @@ func init() { newCmdObjectInstanceSyncResync(kind), newCmdObjectInstanceSyncSplit(kind), newCmdObjectInstanceSyncUpdate(kind), + newCmdObjectSyncList(kind), ) cmdObjectValidate.AddCommand( newCmdObjectValidateConfig(kind), diff --git a/core/ox/factory.go b/core/ox/factory.go index 69b924237..9092a44ae 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1995,6 +1995,24 @@ func newCmdObjectTaskRun(kind string) *cobra.Command { return cmd } +func newCmdObjectSyncList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "sync" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list sync resources", + Long: "List sync resources. Equivalent to 'resource ls --rid sync'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectTaskList(kind string) *cobra.Command { var options commands.CmdObjectResourceList options.RID = "task" diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index 592f9eb0c..c0cb6a38b 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -29,6 +29,7 @@ func init() { cmdObjectResource := commoncmd.NewCmdObjectResource(kind) cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) cmdObjectPush := newCmdObjectPush(kind) + cmdObjectSync := commoncmd.NewCmdObjectSync(kind) cmdObjectValidate := newCmdObjectValidate(kind) root.AddCommand( @@ -53,6 +54,7 @@ func init() { cmdObjectResource, cmdObjectSet, cmdObjectSchedule, + cmdObjectSync, cmdObjectValidate, newCmdDataStoreAdd(kind), newCmdDataStoreChange(kind), @@ -130,6 +132,9 @@ func init() { newCmdObjectInstanceSyncSplit(kind), newCmdObjectInstanceSyncUpdate(kind), ) + cmdObjectSync.AddCommand( + newCmdObjectSyncList(kind), + ) cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), cmdObjectResourceInfo, diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 4f5592d64..91c09ce1b 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -26,6 +26,7 @@ func init() { cmdObjectSchedule := newCmdObjectSchedule(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) + cmdObjectSync := commoncmd.NewCmdObjectSync(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectPrint := newCmdObjectPrint(kind) cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) @@ -54,6 +55,7 @@ func init() { cmdObjectResource, cmdObjectSet, cmdObjectSchedule, + cmdObjectSync, cmdObjectValidate, newCmdObjectAbort(kind), commoncmd.NewCmdObjectClear(kind), @@ -154,6 +156,9 @@ func init() { newCmdObjectInstanceSyncSplit(kind), newCmdObjectInstanceSyncUpdate(kind), ) + cmdObjectSync.AddCommand( + newCmdObjectSyncList(kind), + ) cmdObjectSchedule.AddCommand( newCmdObjectScheduleList(kind), ) From 63d72be356dab879dd5f581011b1c5345ef7cbee Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Mon, 6 Jul 2026 18:26:28 +0200 Subject: [PATCH 22/32] Support the resource id as a positional parm in "sync" commands Example: om svc1 sync update daily --- core/commoncmd/object.go | 4 +- core/om/factory.go | 119 +++++++++++++++++++++++++++++++++++++++ core/om/kind_all.go | 10 ++-- core/om/kind_svc.go | 10 ++-- core/om/kind_vol.go | 10 ++-- core/ox/factory.go | 116 ++++++++++++++++++++++++++++++++++++++ core/ox/kind_all.go | 5 ++ core/ox/kind_svc.go | 5 ++ 8 files changed, 262 insertions(+), 17 deletions(-) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 72f206f13..62b7a2919 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -94,7 +94,7 @@ func NewCmdObjectSync(kind string) *cobra.Command { GroupID: GroupIDSubsystems, Use: "sync", Short: "replicate data, list sync resources", - Hidden: true, + Long: "Replicate instance data, execute sync actions, list sync resources.", Aliases: []string{"syn", "sy"}, } } @@ -111,7 +111,7 @@ func NewCmdObjectResource(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, Use: "resource", - Short: "query object instance resources", + Short: "query, action object instance resources", Aliases: []string{"res"}, } } diff --git a/core/om/factory.go b/core/om/factory.go index bfb99ab02..74ccda142 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2205,6 +2205,125 @@ func newCmdObjectTaskRun(kind string) *cobra.Command { return cmd } +func newCmdObjectSyncUpdate(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncUpdate + cmd := &cobra.Command{ + Use: "update [ID]", + Short: "synchronize the copy of the local dataset on peers", + Long: "Execute a sync update action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagTarget(flags, &options.Target) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectSyncFull(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncFull + cmd := &cobra.Command{ + Use: "full [ID]", + Short: "full copy of the local dataset on peers", + Long: "Execute a sync full action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagTarget(flags, &options.Target) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectSyncIngest(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncIngest + cmd := &cobra.Command{ + Use: "ingest [ID]", + Short: "ingest files received from the active instance", + Long: "Execute a sync ingest action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectSyncResync(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncResync + cmd := &cobra.Command{ + Use: "resync [ID]", + Short: "restore optimal synchronization", + Long: "Execute a sync resync action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectSyncSplit(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncSplit + cmd := &cobra.Command{ + Use: "split [ID]", + Short: "make both ends of a replicated pair read-write", + Long: "Execute a sync split action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectSyncList(kind string) *cobra.Command { var options commands.CmdObjectResourceList options.RID = "sync" diff --git a/core/om/kind_all.go b/core/om/kind_all.go index 80ff095fd..c25676dcc 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -182,11 +182,11 @@ func init() { newCmdObjectPushResourceInfo(kind), ) cmdObjectSync.AddCommand( - newCmdObjectInstanceSyncFull(kind), - newCmdObjectInstanceSyncIngest(kind), - newCmdObjectInstanceSyncResync(kind), - newCmdObjectInstanceSyncSplit(kind), - newCmdObjectInstanceSyncUpdate(kind), + newCmdObjectSyncFull(kind), + newCmdObjectSyncIngest(kind), + newCmdObjectSyncResync(kind), + newCmdObjectSyncSplit(kind), + newCmdObjectSyncUpdate(kind), newCmdObjectSyncList(kind), ) cmdObjectValidate.AddCommand( diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index d03c4f435..0991856e0 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -184,11 +184,11 @@ func init() { newCmdObjectPushResourceInfo(kind), ) cmdObjectSync.AddCommand( - newCmdObjectInstanceSyncFull(kind), - newCmdObjectInstanceSyncIngest(kind), - newCmdObjectInstanceSyncResync(kind), - newCmdObjectInstanceSyncSplit(kind), - newCmdObjectInstanceSyncUpdate(kind), + newCmdObjectSyncFull(kind), + newCmdObjectSyncIngest(kind), + newCmdObjectSyncResync(kind), + newCmdObjectSyncSplit(kind), + newCmdObjectSyncUpdate(kind), newCmdObjectSyncList(kind), ) cmdObjectValidate.AddCommand( diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index 27c3410a8..66c42b3a6 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -171,11 +171,11 @@ func init() { newCmdObjectSetUnprovisioned(kind), ) cmdObjectSync.AddCommand( - newCmdObjectInstanceSyncFull(kind), - newCmdObjectInstanceSyncIngest(kind), - newCmdObjectInstanceSyncResync(kind), - newCmdObjectInstanceSyncSplit(kind), - newCmdObjectInstanceSyncUpdate(kind), + newCmdObjectSyncFull(kind), + newCmdObjectSyncIngest(kind), + newCmdObjectSyncResync(kind), + newCmdObjectSyncSplit(kind), + newCmdObjectSyncUpdate(kind), newCmdObjectSyncList(kind), ) cmdObjectValidate.AddCommand( diff --git a/core/ox/factory.go b/core/ox/factory.go index 9092a44ae..98962f53e 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1995,6 +1995,122 @@ func newCmdObjectTaskRun(kind string) *cobra.Command { return cmd } +func newCmdObjectSyncUpdate(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncUpdate + cmd := &cobra.Command{ + Use: "update [ID]", + Short: "synchronize the copy of the local dataset on peers", + Long: "Execute a sync update action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagTarget(flags, &options.Target) + return cmd +} + +func newCmdObjectSyncFull(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncFull + cmd := &cobra.Command{ + Use: "full [ID]", + Short: "full copy of the local dataset on peers", + Long: "Execute a sync full action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagTarget(flags, &options.Target) + return cmd +} + +func newCmdObjectSyncIngest(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncIngest + cmd := &cobra.Command{ + Use: "ingest [ID]", + Short: "ingest files received from the active instance", + Long: "Execute a sync ingest action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + return cmd +} + +func newCmdObjectSyncResync(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncResync + cmd := &cobra.Command{ + Use: "resync [ID]", + Short: "restore optimal synchronization", + Long: "Execute a sync resync action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagForce(flags, &options.Force) + return cmd +} + +func newCmdObjectSyncSplit(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncSplit + cmd := &cobra.Command{ + Use: "split [ID]", + Short: "make both ends of a replicated pair read-write", + Long: "Execute a sync split action. Specify a sync ID as a positional argument or let om select the sync if unambiguous.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "sync#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagForce(flags, &options.Force) + return cmd +} + func newCmdObjectSyncList(kind string) *cobra.Command { var options commands.CmdObjectResourceList options.RID = "sync" diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index c0cb6a38b..4dfdf367f 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -133,6 +133,11 @@ func init() { newCmdObjectInstanceSyncUpdate(kind), ) cmdObjectSync.AddCommand( + newCmdObjectSyncFull(kind), + newCmdObjectSyncIngest(kind), + newCmdObjectSyncResync(kind), + newCmdObjectSyncSplit(kind), + newCmdObjectSyncUpdate(kind), newCmdObjectSyncList(kind), ) cmdObjectResource.AddCommand( diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 91c09ce1b..4f7f39682 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -157,6 +157,11 @@ func init() { newCmdObjectInstanceSyncUpdate(kind), ) cmdObjectSync.AddCommand( + newCmdObjectSyncFull(kind), + newCmdObjectSyncIngest(kind), + newCmdObjectSyncResync(kind), + newCmdObjectSyncSplit(kind), + newCmdObjectSyncUpdate(kind), newCmdObjectSyncList(kind), ) cmdObjectSchedule.AddCommand( From 6fe96eeb4c5ed45620db120f0884246b619bea17 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Tue, 7 Jul 2026 12:18:04 +0200 Subject: [PATCH 23/32] Mark the core keywords as applicable in the DEFAULT section only So the start_timeout does not appear as applicable to a resource which driver does actually not support it. --- core/object/core_keywords.go | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/core/object/core_keywords.go b/core/object/core_keywords.go index b51853268..d4e06945a 100644 --- a/core/object/core_keywords.go +++ b/core/object/core_keywords.go @@ -571,6 +571,7 @@ var keywordStore = keywords.Store{ Example: "2h", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/timeout"), }, @@ -581,6 +582,7 @@ var keywordStore = keywords.Store{ Example: "10s", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "status_timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/status_timeout"), }, @@ -590,6 +592,7 @@ var keywordStore = keywords.Store{ Example: "1m30s", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "start_timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/start_timeout"), }, @@ -599,6 +602,7 @@ var keywordStore = keywords.Store{ Example: "1m30s", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "stop_timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/stop_timeout"), }, @@ -608,6 +612,7 @@ var keywordStore = keywords.Store{ Default: "true", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "provision", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/provision"), }, @@ -617,6 +622,7 @@ var keywordStore = keywords.Store{ Default: "true", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "unprovision", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/unprovision"), }, @@ -626,6 +632,7 @@ var keywordStore = keywords.Store{ Example: "1m30s", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "provision_timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/provision_timeout"), }, @@ -635,6 +642,7 @@ var keywordStore = keywords.Store{ Example: "1m30s", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "unprovision_timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/unprovision_timeout"), }, @@ -644,6 +652,7 @@ var keywordStore = keywords.Store{ Example: "1m30s", Kind: naming.NewKinds(naming.KindSvc, naming.KindVol), Option: "sync_timeout", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/sync_timeout"), }, @@ -654,6 +663,7 @@ var keywordStore = keywords.Store{ Inherit: keywords.InheritHead, Kind: naming.NewKinds(naming.KindVol), Option: "access", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/access"), }, @@ -663,6 +673,7 @@ var keywordStore = keywords.Store{ Kind: naming.NewKinds(naming.KindVol), Option: "devices_from", Converter: "list", + Section: "DEFAULT", Text: keywords.NewText(fs, "text/kw/core/devices_from"), }, { @@ -671,6 +682,7 @@ var keywordStore = keywords.Store{ Inherit: keywords.InheritHead, Kind: naming.NewKinds(naming.KindVol), Option: "size", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/size"), }, @@ -679,6 +691,7 @@ var keywordStore = keywords.Store{ Inherit: keywords.InheritHead, Kind: naming.NewKinds(naming.KindVol), Option: "pool", + Section: "DEFAULT", Scopable: true, Text: keywords.NewText(fs, "text/kw/core/pool"), }, From 3ea21afe175b5afcf38d6292e49871c954d5a646 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Tue, 7 Jul 2026 14:27:30 +0200 Subject: [PATCH 24/32] Add more per driver-group commandsets * om container|ip|fs|disk|volume|share start|stop|restart|provision|unprovision * om app start|stop|restart --- core/commoncmd/object.go | 61 +++ core/om/factory.go | 951 +++++++++++++++++++++++++++++++++++++++ core/om/kind_svc.go | 57 +++ core/ox/factory.go | 951 +++++++++++++++++++++++++++++++++++++++ core/ox/kind_svc.go | 57 +++ 5 files changed, 2077 insertions(+) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 62b7a2919..2e65676e6 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -38,6 +38,67 @@ func NewCmdObjectContainer(kind string) *cobra.Command { } } +func NewCmdObjectIP(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "ip", + Short: "query, action ip resources", + Aliases: []string{"ipaddr", "address"}, + } +} + +func NewCmdObjectFS(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "fs", + Short: "query, action fs resources", + Aliases: []string{"filesystem"}, + } +} + +func NewCmdObjectVolume(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "volume", + Short: "query, action volume resources", + Aliases: []string{"vol"}, + } +} + +func NewCmdObjectDisk(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "disk", + Short: "query, action disk resources", + } +} + +func NewCmdObjectShare(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "share", + Short: "query, action share resources", + } +} + +func NewCmdObjectApp(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "app", + Short: "query, action app resources", + Aliases: []string{"application"}, + } +} + +func NewCmdObjectGroups(kind string) *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "groups", + Short: "query, action groups resources", + Aliases: []string{"grp"}, + } +} + func NewCmdObjectTask(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, diff --git a/core/om/factory.go b/core/om/factory.go index 74ccda142..5162e4656 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2175,6 +2175,957 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectContainerStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a container resource", + Long: "Start a container resource. Specify a container ID as a positional argument. Equivalent to 'instance start --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectContainerStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a container resource", + Long: "Stop a container resource. Specify a container ID as a positional argument. Equivalent to 'instance stop --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectContainerRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a container resource", + Long: "Restart a container resource. Specify a container ID as a positional argument. Equivalent to 'instance restart --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectContainerProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a container resource", + Long: "Provision a container resource. Specify a container ID as a positional argument. Equivalent to 'instance provision --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectContainerUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a container resource", + Long: "Unprovision a container resource. Specify a container ID as a positional argument. Equivalent to 'instance unprovision --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectIPStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start an ip resource", + Long: "Start an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance start --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectIPStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop an ip resource", + Long: "Stop an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance stop --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectIPRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart an ip resource", + Long: "Restart an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance restart --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectIPProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision an ip resource", + Long: "Provision an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance provision --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectIPUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision an ip resource", + Long: "Unprovision an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance unprovision --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectFSStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a fs resource", + Long: "Start a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance start --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectFSStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a fs resource", + Long: "Stop a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance stop --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectFSRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a fs resource", + Long: "Restart a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance restart --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectFSProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a fs resource", + Long: "Provision a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance provision --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectFSUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a fs resource", + Long: "Unprovision a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance unprovision --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectVolumeStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a volume resource", + Long: "Start a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance start --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectVolumeStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a volume resource", + Long: "Stop a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance stop --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectVolumeRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a volume resource", + Long: "Restart a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance restart --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectVolumeProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a volume resource", + Long: "Provision a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance provision --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectVolumeUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a volume resource", + Long: "Unprovision a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance unprovision --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectDiskStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a disk resource", + Long: "Start a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance start --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a disk resource", + Long: "Stop a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance stop --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a disk resource", + Long: "Restart a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance restart --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a disk resource", + Long: "Provision a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance provision --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectDiskUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a disk resource", + Long: "Unprovision a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance unprovision --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectShareStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a share resource", + Long: "Start a share resource. Specify a share ID as a positional argument. Equivalent to 'instance start --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectShareStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a share resource", + Long: "Stop a share resource. Specify a share ID as a positional argument. Equivalent to 'instance stop --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectShareRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a share resource", + Long: "Restart a share resource. Specify a share ID as a positional argument. Equivalent to 'instance restart --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectShareProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a share resource", + Long: "Provision a share resource. Specify a share ID as a positional argument. Equivalent to 'instance provision --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectShareUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a share resource", + Long: "Unprovision a share resource. Specify a share ID as a positional argument. Equivalent to 'instance unprovision --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectAppStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start an app resource", + Long: "Start an app resource. Specify an app ID as a positional argument. Equivalent to 'instance start --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectAppStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop an app resource", + Long: "Stop an app resource. Specify an app ID as a positional argument. Equivalent to 'instance stop --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectAppRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart an app resource", + Long: "Restart an app resource. Specify an app ID as a positional argument. Equivalent to 'instance restart --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + func newCmdObjectTaskRun(kind string) *cobra.Command { var options commands.CmdObjectInstanceRun cmd := &cobra.Command{ diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index 0991856e0..a0de15566 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -19,6 +19,12 @@ func init() { cmdObjectComplianceList := newCmdObjectComplianceList(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectIP := commoncmd.NewCmdObjectIP(kind) + cmdObjectFS := commoncmd.NewCmdObjectFS(kind) + cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) + cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) + cmdObjectShare := commoncmd.NewCmdObjectShare(kind) + cmdObjectApp := commoncmd.NewCmdObjectApp(kind) cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) @@ -50,6 +56,12 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectIP, + cmdObjectFS, + cmdObjectVolume, + cmdObjectDisk, + cmdObjectShare, + cmdObjectApp, cmdObjectTask, cmdObjectEdit, cmdObjectInstance, @@ -108,6 +120,51 @@ func init() { newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), + newCmdObjectContainerStart(kind), + newCmdObjectContainerStop(kind), + newCmdObjectContainerRestart(kind), + newCmdObjectContainerProvision(kind), + newCmdObjectContainerUnprovision(kind), + ) + cmdObjectIP.AddCommand( + newCmdObjectIPStart(kind), + newCmdObjectIPStop(kind), + newCmdObjectIPRestart(kind), + newCmdObjectIPProvision(kind), + newCmdObjectIPUnprovision(kind), + ) + cmdObjectFS.AddCommand( + newCmdObjectFSStart(kind), + newCmdObjectFSStop(kind), + newCmdObjectFSRestart(kind), + newCmdObjectFSProvision(kind), + newCmdObjectFSUnprovision(kind), + ) + cmdObjectVolume.AddCommand( + newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStop(kind), + newCmdObjectVolumeRestart(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumeUnprovision(kind), + ) + cmdObjectDisk.AddCommand( + newCmdObjectDiskStart(kind), + newCmdObjectDiskStop(kind), + newCmdObjectDiskRestart(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskUnprovision(kind), + ) + cmdObjectShare.AddCommand( + newCmdObjectShareStart(kind), + newCmdObjectShareStop(kind), + newCmdObjectShareRestart(kind), + newCmdObjectShareProvision(kind), + newCmdObjectShareUnprovision(kind), + ) + cmdObjectApp.AddCommand( + newCmdObjectAppStart(kind), + newCmdObjectAppStop(kind), + newCmdObjectAppRestart(kind), ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), diff --git a/core/ox/factory.go b/core/ox/factory.go index 98962f53e..7615c172d 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1967,6 +1967,957 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectContainerStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a container resource", + Long: "Start a container resource. Specify a container ID as a positional argument. Equivalent to 'instance start --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectContainerStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a container resource", + Long: "Stop a container resource. Specify a container ID as a positional argument. Equivalent to 'instance stop --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectContainerRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a container resource", + Long: "Restart a container resource. Specify a container ID as a positional argument. Equivalent to 'instance restart --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectContainerProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a container resource", + Long: "Provision a container resource. Specify a container ID as a positional argument. Equivalent to 'instance provision --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectContainerUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a container resource", + Long: "Unprovision a container resource. Specify a container ID as a positional argument. Equivalent to 'instance unprovision --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectIPStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start an ip resource", + Long: "Start an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance start --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectIPStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop an ip resource", + Long: "Stop an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance stop --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectIPRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart an ip resource", + Long: "Restart an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance restart --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectIPProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision an ip resource", + Long: "Provision an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance provision --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectIPUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision an ip resource", + Long: "Unprovision an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance unprovision --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectFSStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a fs resource", + Long: "Start a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance start --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectFSStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a fs resource", + Long: "Stop a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance stop --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectFSRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a fs resource", + Long: "Restart a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance restart --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectFSProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a fs resource", + Long: "Provision a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance provision --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectFSUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a fs resource", + Long: "Unprovision a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance unprovision --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectVolumeStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a volume resource", + Long: "Start a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance start --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectVolumeStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a volume resource", + Long: "Stop a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance stop --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectVolumeRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a volume resource", + Long: "Restart a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance restart --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectVolumeProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a volume resource", + Long: "Provision a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance provision --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectVolumeUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a volume resource", + Long: "Unprovision a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance unprovision --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectDiskStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a disk resource", + Long: "Start a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance start --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a disk resource", + Long: "Stop a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance stop --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a disk resource", + Long: "Restart a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance restart --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a disk resource", + Long: "Provision a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance provision --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectDiskUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a disk resource", + Long: "Unprovision a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance unprovision --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectShareStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a share resource", + Long: "Start a share resource. Specify a share ID as a positional argument. Equivalent to 'instance start --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectShareStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop a share resource", + Long: "Stop a share resource. Specify a share ID as a positional argument. Equivalent to 'instance stop --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectShareRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart a share resource", + Long: "Restart a share resource. Specify a share ID as a positional argument. Equivalent to 'instance restart --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectShareProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision [ID]", + Short: "provision a share resource", + Long: "Provision a share resource. Specify a share ID as a positional argument. Equivalent to 'instance provision --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectShareUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision [ID]", + Short: "unprovision a share resource", + Long: "Unprovision a share resource. Specify a share ID as a positional argument. Equivalent to 'instance unprovision --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectAppStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start an app resource", + Long: "Start an app resource. Specify an app ID as a positional argument. Equivalent to 'instance start --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectAppStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop [ID]", + Short: "stop an app resource", + Long: "Stop an app resource. Specify an app ID as a positional argument. Equivalent to 'instance stop --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectAppRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart an app resource", + Long: "Restart an app resource. Specify an app ID as a positional argument. Equivalent to 'instance restart --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + func newCmdObjectTaskRun(kind string) *cobra.Command { var options commands.CmdObjectInstanceRun cmd := &cobra.Command{ diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 4f7f39682..8205d2ccd 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -15,6 +15,12 @@ func init() { cmdObjectComplianceList := newCmdObjectComplianceList(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectIP := commoncmd.NewCmdObjectIP(kind) + cmdObjectFS := commoncmd.NewCmdObjectFS(kind) + cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) + cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) + cmdObjectShare := commoncmd.NewCmdObjectShare(kind) + cmdObjectApp := commoncmd.NewCmdObjectApp(kind) cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) @@ -46,6 +52,12 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectIP, + cmdObjectFS, + cmdObjectVolume, + cmdObjectDisk, + cmdObjectShare, + cmdObjectApp, cmdObjectTask, cmdObjectEdit, cmdObjectInstance, @@ -101,6 +113,51 @@ func init() { newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), + newCmdObjectContainerStart(kind), + newCmdObjectContainerStop(kind), + newCmdObjectContainerRestart(kind), + newCmdObjectContainerProvision(kind), + newCmdObjectContainerUnprovision(kind), + ) + cmdObjectIP.AddCommand( + newCmdObjectIPStart(kind), + newCmdObjectIPStop(kind), + newCmdObjectIPRestart(kind), + newCmdObjectIPProvision(kind), + newCmdObjectIPUnprovision(kind), + ) + cmdObjectFS.AddCommand( + newCmdObjectFSStart(kind), + newCmdObjectFSStop(kind), + newCmdObjectFSRestart(kind), + newCmdObjectFSProvision(kind), + newCmdObjectFSUnprovision(kind), + ) + cmdObjectVolume.AddCommand( + newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStop(kind), + newCmdObjectVolumeRestart(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumeUnprovision(kind), + ) + cmdObjectDisk.AddCommand( + newCmdObjectDiskStart(kind), + newCmdObjectDiskStop(kind), + newCmdObjectDiskRestart(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskUnprovision(kind), + ) + cmdObjectShare.AddCommand( + newCmdObjectShareStart(kind), + newCmdObjectShareStop(kind), + newCmdObjectShareRestart(kind), + newCmdObjectShareProvision(kind), + newCmdObjectShareUnprovision(kind), + ) + cmdObjectApp.AddCommand( + newCmdObjectAppStart(kind), + newCmdObjectAppStop(kind), + newCmdObjectAppRestart(kind), ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), From b091153a1d6cd59cd55d8cdc2a427ff30dedbb63 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Tue, 7 Jul 2026 15:00:38 +0200 Subject: [PATCH 25/32] Group resource group commands in the help Example: Resource Groups: app list, action app resources container list, action container resources, enter, stream logs disk list, action disk resources fs list, action fs resources ip list, action ip resources share list, action share resources sync list, action sync resources task list, run tasks volume list, action volume resources --- core/commoncmd/groups.go | 8 +++++++ core/commoncmd/object.go | 45 ++++++++++++++++------------------------ core/om/kind_all.go | 1 + core/om/kind_svc.go | 1 + core/om/kind_vol.go | 1 + core/ox/kind_all.go | 1 + core/ox/kind_svc.go | 1 + core/ox/kind_vol.go | 1 + 8 files changed, 32 insertions(+), 27 deletions(-) diff --git a/core/commoncmd/groups.go b/core/commoncmd/groups.go index 8d801dc79..030523fa7 100644 --- a/core/commoncmd/groups.go +++ b/core/commoncmd/groups.go @@ -6,6 +6,7 @@ var ( GroupIDOrchestratedActions = "orchestrated actions" GroupIDQuery = "query" GroupIDSubsystems = "subsystems" + GroupIDResourceGroups = "resource groups" ) func NewGroupOrchestratedActions() *cobra.Group { @@ -28,3 +29,10 @@ func NewGroupSubsystems() *cobra.Group { Title: "Subsystems:", } } + +func NewGroupResources() *cobra.Group { + return &cobra.Group{ + ID: GroupIDResourceGroups, + Title: "Resource Groups:", + } +} diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 2e65676e6..d5aa8b81c 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -32,76 +32,67 @@ func NewCmdObjectConfig(kind string) *cobra.Command { func NewCmdObjectContainer(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "container", - Short: "enter, stream logs", + Short: "list, action container resources, enter, stream logs", } } func NewCmdObjectIP(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "ip", - Short: "query, action ip resources", + Short: "list, action ip resources", Aliases: []string{"ipaddr", "address"}, } } func NewCmdObjectFS(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "fs", - Short: "query, action fs resources", + Short: "list, action fs resources", Aliases: []string{"filesystem"}, } } func NewCmdObjectVolume(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "volume", - Short: "query, action volume resources", + Short: "list, action volume resources", Aliases: []string{"vol"}, } } func NewCmdObjectDisk(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "disk", - Short: "query, action disk resources", + Short: "list, action disk resources", } } func NewCmdObjectShare(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "share", - Short: "query, action share resources", + Short: "list, action share resources", } } func NewCmdObjectApp(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "app", - Short: "query, action app resources", + Short: "list, action app resources", Aliases: []string{"application"}, } } -func NewCmdObjectGroups(kind string) *cobra.Command { - return &cobra.Command{ - GroupID: GroupIDSubsystems, - Use: "groups", - Short: "query, action groups resources", - Aliases: []string{"grp"}, - } -} - func NewCmdObjectTask(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "task", Short: "list, run tasks", } @@ -152,9 +143,9 @@ func NewCmdObjectSSH(kind string) *cobra.Command { func NewCmdObjectSync(kind string) *cobra.Command { return &cobra.Command{ - GroupID: GroupIDSubsystems, + GroupID: GroupIDResourceGroups, Use: "sync", - Short: "replicate data, list sync resources", + Short: "list, action sync resources", Long: "Replicate instance data, execute sync actions, list sync resources.", Aliases: []string{"syn", "sy"}, } @@ -172,7 +163,7 @@ func NewCmdObjectResource(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, Use: "resource", - Short: "query, action object instance resources", + Short: "list, action object instance resources", Aliases: []string{"res"}, } } diff --git a/core/om/kind_all.go b/core/om/kind_all.go index c25676dcc..de71cf79a 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -39,6 +39,7 @@ func init() { cmdObject.AddGroup( commoncmd.NewGroupOrchestratedActions(), commoncmd.NewGroupQuery(), + commoncmd.NewGroupResources(), commoncmd.NewGroupSubsystems(), ) root.AddCommand( diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index a0de15566..81a62df6d 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -49,6 +49,7 @@ func init() { cmdObject.AddGroup( commoncmd.NewGroupOrchestratedActions(), commoncmd.NewGroupQuery(), + commoncmd.NewGroupResources(), commoncmd.NewGroupSubsystems(), ) cmdObject.AddCommand( diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index 66c42b3a6..b553ae9a0 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -36,6 +36,7 @@ func init() { cmdObject.AddGroup( commoncmd.NewGroupOrchestratedActions(), commoncmd.NewGroupQuery(), + commoncmd.NewGroupResources(), commoncmd.NewGroupSubsystems(), ) cmdObject.AddCommand( diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index 4dfdf367f..b86272537 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -38,6 +38,7 @@ func init() { cmdObject.AddGroup( commoncmd.NewGroupOrchestratedActions(), commoncmd.NewGroupQuery(), + commoncmd.NewGroupResources(), commoncmd.NewGroupSubsystems(), ) cmdObject.AddCommand( diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 8205d2ccd..5a0f2c0de 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -45,6 +45,7 @@ func init() { cmdObject.AddGroup( commoncmd.NewGroupOrchestratedActions(), commoncmd.NewGroupQuery(), + commoncmd.NewGroupResources(), commoncmd.NewGroupSubsystems(), ) cmdObject.AddCommand( diff --git a/core/ox/kind_vol.go b/core/ox/kind_vol.go index 1bfc31120..64c7d6673 100644 --- a/core/ox/kind_vol.go +++ b/core/ox/kind_vol.go @@ -31,6 +31,7 @@ func init() { cmdObject.AddGroup( commoncmd.NewGroupOrchestratedActions(), commoncmd.NewGroupQuery(), + commoncmd.NewGroupResources(), commoncmd.NewGroupSubsystems(), ) cmdObject.AddCommand( From 29165c12f9d39c05e8600619dcd33f8a592f192f Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Tue, 7 Jul 2026 16:09:55 +0200 Subject: [PATCH 26/32] Add the missing res-group list commands Make sure "om svc* " (without the positional parameter) works only on , instead of all resources. Add the res-groups actions to the "all" command subtree. --- core/commoncmd/object.go | 24 ++--- core/om/factory.go | 226 +++++++++++++++++++++++++++++++++++++++ core/om/kind_all.go | 63 +++++++++++ core/om/kind_svc.go | 8 +- core/om/kind_vol.go | 10 ++ core/ox/factory.go | 144 +++++++++++++++++++++++++ core/ox/kind_all.go | 30 ++++++ core/ox/kind_svc.go | 6 ++ core/ox/kind_vol.go | 10 ++ 9 files changed, 508 insertions(+), 13 deletions(-) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index d5aa8b81c..59f053d94 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -26,7 +26,7 @@ func NewCmdObjectConfig(kind string) *cobra.Command { GroupID: GroupIDSubsystems, Use: "config", Aliases: []string{"conf", "cf", "cfg"}, - Short: "show, alter object configuration", + Short: "show, edit, update, ...", } } @@ -34,7 +34,7 @@ func NewCmdObjectContainer(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "container", - Short: "list, action container resources, enter, stream logs", + Short: "list, start, stop, enter, logs, ...", } } @@ -42,7 +42,7 @@ func NewCmdObjectIP(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "ip", - Short: "list, action ip resources", + Short: "list, start, stop, ...", Aliases: []string{"ipaddr", "address"}, } } @@ -51,7 +51,7 @@ func NewCmdObjectFS(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "fs", - Short: "list, action fs resources", + Short: "list, start, stop, ...", Aliases: []string{"filesystem"}, } } @@ -60,7 +60,7 @@ func NewCmdObjectVolume(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "volume", - Short: "list, action volume resources", + Short: "list, start, stop, ...", Aliases: []string{"vol"}, } } @@ -69,7 +69,7 @@ func NewCmdObjectDisk(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "disk", - Short: "list, action disk resources", + Short: "list, start, stop, ...", } } @@ -77,7 +77,7 @@ func NewCmdObjectShare(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "share", - Short: "list, action share resources", + Short: "list, start, stop, ...", } } @@ -85,7 +85,7 @@ func NewCmdObjectApp(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "app", - Short: "list, action app resources", + Short: "list, start, stop, ...", Aliases: []string{"application"}, } } @@ -94,7 +94,7 @@ func NewCmdObjectTask(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "task", - Short: "list, run tasks", + Short: "list, run, ...", } } @@ -102,7 +102,7 @@ func NewCmdObjectInstance(kind string) *cobra.Command { cmd := &cobra.Command{ GroupID: GroupIDSubsystems, Use: "instance", - Short: "query, action object instances", + Short: "list, start, stop, ...", Aliases: []string{"inst"}, } cmd.AddGroup( @@ -145,7 +145,7 @@ func NewCmdObjectSync(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDResourceGroups, Use: "sync", - Short: "list, action sync resources", + Short: "list, update, ...", Long: "Replicate instance data, execute sync actions, list sync resources.", Aliases: []string{"syn", "sy"}, } @@ -163,7 +163,7 @@ func NewCmdObjectResource(kind string) *cobra.Command { return &cobra.Command{ GroupID: GroupIDSubsystems, Use: "resource", - Short: "list, action object instance resources", + Short: "list, start, stop, ...", Aliases: []string{"res"}, } } diff --git a/core/om/factory.go b/core/om/factory.go index 5162e4656..a77695526 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2124,6 +2124,8 @@ func newCmdObjectContainerEnter(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2145,6 +2147,8 @@ func newCmdObjectContainerLogs(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2175,6 +2179,150 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectIPList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "ip" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list ip resources", + Long: "List ip resources. Equivalent to 'resource ls --rid ip'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectFSList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "fs" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list fs resources", + Long: "List fs resources. Equivalent to 'resource ls --rid fs'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectVolumeList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "volume" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list volume resources", + Long: "List volume resources. Equivalent to 'resource ls --rid volume'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDiskList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "disk" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list disk resources", + Long: "List disk resources. Equivalent to 'resource ls --rid disk'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectShareList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "share" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list share resources", + Long: "List share resources. Equivalent to 'resource ls --rid share'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectAppList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "app" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list app resources", + Long: "List app resources. Equivalent to 'resource ls --rid app'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDriverList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "driver" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list driver resources", + Long: "List driver resources. Equivalent to 'resource ls --rid driver'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectGroupsList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "groups" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list groups resources", + Long: "List groups resources. Equivalent to 'resource ls --rid groups'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectContainerStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -2185,6 +2333,8 @@ func newCmdObjectContainerStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2214,6 +2364,8 @@ func newCmdObjectContainerStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2243,6 +2395,8 @@ func newCmdObjectContainerRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2272,6 +2426,8 @@ func newCmdObjectContainerProvision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2301,6 +2457,8 @@ func newCmdObjectContainerUnprovision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" } return options.Run(kind) }, @@ -2329,6 +2487,8 @@ func newCmdObjectIPStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" } return options.Run(kind) }, @@ -2358,6 +2518,8 @@ func newCmdObjectIPStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" } return options.Run(kind) }, @@ -2387,6 +2549,8 @@ func newCmdObjectIPRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" } return options.Run(kind) }, @@ -2416,6 +2580,8 @@ func newCmdObjectIPProvision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" } return options.Run(kind) }, @@ -2445,6 +2611,8 @@ func newCmdObjectIPUnprovision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" } return options.Run(kind) }, @@ -2473,6 +2641,8 @@ func newCmdObjectFSStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" } return options.Run(kind) }, @@ -2502,6 +2672,8 @@ func newCmdObjectFSStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" } return options.Run(kind) }, @@ -2531,6 +2703,8 @@ func newCmdObjectFSRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" } return options.Run(kind) }, @@ -2560,6 +2734,8 @@ func newCmdObjectFSProvision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" } return options.Run(kind) }, @@ -2589,6 +2765,8 @@ func newCmdObjectFSUnprovision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" } return options.Run(kind) }, @@ -2617,6 +2795,8 @@ func newCmdObjectVolumeStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" } return options.Run(kind) }, @@ -2646,6 +2826,8 @@ func newCmdObjectVolumeStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" } return options.Run(kind) }, @@ -2675,6 +2857,8 @@ func newCmdObjectVolumeRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" } return options.Run(kind) }, @@ -2704,6 +2888,8 @@ func newCmdObjectVolumeProvision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" } return options.Run(kind) }, @@ -2733,6 +2919,8 @@ func newCmdObjectVolumeUnprovision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" } return options.Run(kind) }, @@ -2761,6 +2949,8 @@ func newCmdObjectDiskStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" } return options.Run(kind) }, @@ -2790,6 +2980,8 @@ func newCmdObjectDiskStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" } return options.Run(kind) }, @@ -2819,6 +3011,8 @@ func newCmdObjectDiskRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" } return options.Run(kind) }, @@ -2848,6 +3042,8 @@ func newCmdObjectDiskProvision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" } return options.Run(kind) }, @@ -2877,6 +3073,8 @@ func newCmdObjectDiskUnprovision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" } return options.Run(kind) }, @@ -2905,6 +3103,8 @@ func newCmdObjectShareStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" } return options.Run(kind) }, @@ -2934,6 +3134,8 @@ func newCmdObjectShareStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" } return options.Run(kind) }, @@ -2963,6 +3165,8 @@ func newCmdObjectShareRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" } return options.Run(kind) }, @@ -2992,6 +3196,8 @@ func newCmdObjectShareProvision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" } return options.Run(kind) }, @@ -3021,6 +3227,8 @@ func newCmdObjectShareUnprovision(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" } return options.Run(kind) }, @@ -3049,6 +3257,8 @@ func newCmdObjectAppStart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "app#" + args[0] + } else if options.RID == "" { + options.RID = "app" } return options.Run(kind) }, @@ -3078,6 +3288,8 @@ func newCmdObjectAppStop(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "app#" + args[0] + } else if options.RID == "" { + options.RID = "app" } return options.Run(kind) }, @@ -3107,6 +3319,8 @@ func newCmdObjectAppRestart(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "app#" + args[0] + } else if options.RID == "" { + options.RID = "app" } return options.Run(kind) }, @@ -3136,6 +3350,8 @@ func newCmdObjectTaskRun(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "task#" + args[0] + } else if options.RID == "" { + options.RID = "task" } return options.Run(kind) }, @@ -3166,6 +3382,8 @@ func newCmdObjectSyncUpdate(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "sync#" + args[0] + } else if options.RID == "" { + options.RID = "sync" } return options.Run(kind) }, @@ -3191,6 +3409,8 @@ func newCmdObjectSyncFull(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "sync#" + args[0] + } else if options.RID == "" { + options.RID = "sync" } return options.Run(kind) }, @@ -3216,6 +3436,8 @@ func newCmdObjectSyncIngest(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "sync#" + args[0] + } else if options.RID == "" { + options.RID = "sync" } return options.Run(kind) }, @@ -3239,6 +3461,8 @@ func newCmdObjectSyncResync(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "sync#" + args[0] + } else if options.RID == "" { + options.RID = "sync" } return options.Run(kind) }, @@ -3262,6 +3486,8 @@ func newCmdObjectSyncSplit(kind string) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { options.RID = "sync#" + args[0] + } else if options.RID == "" { + options.RID = "sync" } return options.Run(kind) }, diff --git a/core/om/kind_all.go b/core/om/kind_all.go index de71cf79a..a467a8ead 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -18,6 +18,12 @@ func init() { cmdObjectComplianceList := newCmdObjectComplianceList(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectIP := commoncmd.NewCmdObjectIP(kind) + cmdObjectFS := commoncmd.NewCmdObjectFS(kind) + cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) + cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) + cmdObjectShare := commoncmd.NewCmdObjectShare(kind) + cmdObjectApp := commoncmd.NewCmdObjectApp(kind) cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) @@ -50,6 +56,12 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectIP, + cmdObjectFS, + cmdObjectVolume, + cmdObjectDisk, + cmdObjectShare, + cmdObjectApp, cmdObjectTask, cmdObjectEdit, cmdObjectInstance, @@ -149,12 +161,63 @@ func init() { newCmdObjectConfigShow(kind), newCmdObjectConfigUpdate(kind), newCmdObjectConfigValidate(kind), + newCmdObjectContainerStart(kind), + newCmdObjectContainerStop(kind), + newCmdObjectContainerRestart(kind), + newCmdObjectContainerProvision(kind), + newCmdObjectContainerUnprovision(kind), ) cmdObjectContainer.AddCommand( newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), ) + cmdObjectIP.AddCommand( + newCmdObjectIPList(kind), + newCmdObjectIPStart(kind), + newCmdObjectIPStop(kind), + newCmdObjectIPRestart(kind), + newCmdObjectIPProvision(kind), + newCmdObjectIPUnprovision(kind), + ) + cmdObjectFS.AddCommand( + newCmdObjectFSList(kind), + newCmdObjectFSStart(kind), + newCmdObjectFSStop(kind), + newCmdObjectFSRestart(kind), + newCmdObjectFSProvision(kind), + newCmdObjectFSUnprovision(kind), + ) + cmdObjectVolume.AddCommand( + newCmdObjectVolumeList(kind), + newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStop(kind), + newCmdObjectVolumeRestart(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumeUnprovision(kind), + ) + cmdObjectDisk.AddCommand( + newCmdObjectDiskList(kind), + newCmdObjectDiskStart(kind), + newCmdObjectDiskStop(kind), + newCmdObjectDiskRestart(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskUnprovision(kind), + ) + cmdObjectShare.AddCommand( + newCmdObjectShareList(kind), + newCmdObjectShareStart(kind), + newCmdObjectShareStop(kind), + newCmdObjectShareRestart(kind), + newCmdObjectShareProvision(kind), + newCmdObjectShareUnprovision(kind), + ) + cmdObjectApp.AddCommand( + newCmdObjectAppList(kind), + newCmdObjectAppRestart(kind), + newCmdObjectAppStop(kind), + newCmdObjectAppStart(kind), + ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), newCmdObjectTaskRun(kind), diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index 81a62df6d..952c21f6e 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -128,6 +128,7 @@ func init() { newCmdObjectContainerUnprovision(kind), ) cmdObjectIP.AddCommand( + newCmdObjectIPList(kind), newCmdObjectIPStart(kind), newCmdObjectIPStop(kind), newCmdObjectIPRestart(kind), @@ -135,6 +136,7 @@ func init() { newCmdObjectIPUnprovision(kind), ) cmdObjectFS.AddCommand( + newCmdObjectFSList(kind), newCmdObjectFSStart(kind), newCmdObjectFSStop(kind), newCmdObjectFSRestart(kind), @@ -142,6 +144,7 @@ func init() { newCmdObjectFSUnprovision(kind), ) cmdObjectVolume.AddCommand( + newCmdObjectVolumeList(kind), newCmdObjectVolumeStart(kind), newCmdObjectVolumeStop(kind), newCmdObjectVolumeRestart(kind), @@ -149,6 +152,7 @@ func init() { newCmdObjectVolumeUnprovision(kind), ) cmdObjectDisk.AddCommand( + newCmdObjectDiskList(kind), newCmdObjectDiskStart(kind), newCmdObjectDiskStop(kind), newCmdObjectDiskRestart(kind), @@ -156,6 +160,7 @@ func init() { newCmdObjectDiskUnprovision(kind), ) cmdObjectShare.AddCommand( + newCmdObjectShareList(kind), newCmdObjectShareStart(kind), newCmdObjectShareStop(kind), newCmdObjectShareRestart(kind), @@ -163,9 +168,10 @@ func init() { newCmdObjectShareUnprovision(kind), ) cmdObjectApp.AddCommand( + newCmdObjectAppList(kind), + newCmdObjectAppRestart(kind), newCmdObjectAppStart(kind), newCmdObjectAppStop(kind), - newCmdObjectAppRestart(kind), ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index b553ae9a0..f764277fb 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -14,6 +14,8 @@ func init() { cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) + cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) + cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) @@ -42,6 +44,8 @@ func init() { cmdObject.AddCommand( cmdObjectCollector, cmdObjectConfig, + cmdObjectVolume, + cmdObjectDisk, cmdObjectEdit, cmdObjectInstance, cmdObjectPG, @@ -82,6 +86,12 @@ func init() { newCmdObjectUnprovision(kind), newCmdObjectUnset(kind), ) + cmdObjectVolume.AddCommand( + newCmdObjectVolumeList(kind), + ) + cmdObjectDisk.AddCommand( + newCmdObjectDiskList(kind), + ) cmdObjectCollector.AddCommand( cmdObjectCollectorTag, ) diff --git a/core/ox/factory.go b/core/ox/factory.go index 7615c172d..11138132f 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -1967,6 +1967,150 @@ func newCmdObjectContainerList(kind string) *cobra.Command { return cmd } +func newCmdObjectIPList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "ip" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list ip resources", + Long: "List ip resources. Equivalent to 'resource ls --rid ip'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectFSList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "fs" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list fs resources", + Long: "List fs resources. Equivalent to 'resource ls --rid fs'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectVolumeList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "volume" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list volume resources", + Long: "List volume resources. Equivalent to 'resource ls --rid volume'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDiskList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "disk" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list disk resources", + Long: "List disk resources. Equivalent to 'resource ls --rid disk'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectShareList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "share" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list share resources", + Long: "List share resources. Equivalent to 'resource ls --rid share'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectAppList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "app" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list app resources", + Long: "List app resources. Equivalent to 'resource ls --rid app'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDriverList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "driver" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list driver resources", + Long: "List driver resources. Equivalent to 'resource ls --rid driver'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectGroupsList(kind string) *cobra.Command { + var options commands.CmdObjectResourceList + options.RID = "groups" + cmd := &cobra.Command{ + Use: "list", + Aliases: []string{"ls"}, + Short: "list groups resources", + Long: "List groups resources. Equivalent to 'resource ls --rid groups'.", + RunE: func(cmd *cobra.Command, args []string) error { + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectContainerStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index b86272537..03829cc8a 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -23,6 +23,12 @@ func init() { cmdObjectSet := newCmdObjectSet(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectContainer := commoncmd.NewCmdObjectContainer(kind) + cmdObjectIP := commoncmd.NewCmdObjectIP(kind) + cmdObjectFS := commoncmd.NewCmdObjectFS(kind) + cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) + cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) + cmdObjectShare := commoncmd.NewCmdObjectShare(kind) + cmdObjectApp := commoncmd.NewCmdObjectApp(kind) cmdObjectTask := commoncmd.NewCmdObjectTask(kind) cmdObjectPrint := newCmdObjectPrint(kind) cmdObjectPrintConfig := newCmdObjectPrintConfig(kind) @@ -46,6 +52,12 @@ func init() { cmdObjectCompliance, cmdObjectConfig, cmdObjectContainer, + cmdObjectIP, + cmdObjectFS, + cmdObjectVolume, + cmdObjectDisk, + cmdObjectShare, + cmdObjectApp, cmdObjectTask, cmdObjectEdit, cmdObjectInstance, @@ -159,6 +171,24 @@ func init() { newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), ) + cmdObjectIP.AddCommand( + newCmdObjectIPList(kind), + ) + cmdObjectFS.AddCommand( + newCmdObjectFSList(kind), + ) + cmdObjectVolume.AddCommand( + newCmdObjectVolumeList(kind), + ) + cmdObjectDisk.AddCommand( + newCmdObjectDiskList(kind), + ) + cmdObjectShare.AddCommand( + newCmdObjectShareList(kind), + ) + cmdObjectApp.AddCommand( + newCmdObjectAppList(kind), + ) cmdObjectTask.AddCommand( newCmdObjectTaskList(kind), newCmdObjectTaskRun(kind), diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 5a0f2c0de..38fb775aa 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -121,6 +121,7 @@ func init() { newCmdObjectContainerUnprovision(kind), ) cmdObjectIP.AddCommand( + newCmdObjectIPList(kind), newCmdObjectIPStart(kind), newCmdObjectIPStop(kind), newCmdObjectIPRestart(kind), @@ -128,6 +129,7 @@ func init() { newCmdObjectIPUnprovision(kind), ) cmdObjectFS.AddCommand( + newCmdObjectFSList(kind), newCmdObjectFSStart(kind), newCmdObjectFSStop(kind), newCmdObjectFSRestart(kind), @@ -135,6 +137,7 @@ func init() { newCmdObjectFSUnprovision(kind), ) cmdObjectVolume.AddCommand( + newCmdObjectVolumeList(kind), newCmdObjectVolumeStart(kind), newCmdObjectVolumeStop(kind), newCmdObjectVolumeRestart(kind), @@ -142,6 +145,7 @@ func init() { newCmdObjectVolumeUnprovision(kind), ) cmdObjectDisk.AddCommand( + newCmdObjectDiskList(kind), newCmdObjectDiskStart(kind), newCmdObjectDiskStop(kind), newCmdObjectDiskRestart(kind), @@ -149,6 +153,7 @@ func init() { newCmdObjectDiskUnprovision(kind), ) cmdObjectShare.AddCommand( + newCmdObjectShareList(kind), newCmdObjectShareStart(kind), newCmdObjectShareStop(kind), newCmdObjectShareRestart(kind), @@ -156,6 +161,7 @@ func init() { newCmdObjectShareUnprovision(kind), ) cmdObjectApp.AddCommand( + newCmdObjectAppList(kind), newCmdObjectAppStart(kind), newCmdObjectAppStop(kind), newCmdObjectAppRestart(kind), diff --git a/core/ox/kind_vol.go b/core/ox/kind_vol.go index 64c7d6673..f5dc8c505 100644 --- a/core/ox/kind_vol.go +++ b/core/ox/kind_vol.go @@ -9,6 +9,8 @@ func init() { cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) + cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) + cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) @@ -37,6 +39,8 @@ func init() { cmdObject.AddCommand( cmdObjectCollector, cmdObjectConfig, + cmdObjectVolume, + cmdObjectDisk, cmdObjectEdit, cmdObjectInstance, cmdObjectPG, @@ -74,6 +78,12 @@ func init() { newCmdObjectUpdate(kind), newCmdTUI(kind), ) + cmdObjectVolume.AddCommand( + newCmdObjectVolumeList(kind), + ) + cmdObjectDisk.AddCommand( + newCmdObjectDiskList(kind), + ) cmdObjectCollector.AddCommand( cmdObjectCollectorTag, ) From 2a0dc1db2c1c56786618a9aea30979eda0aa1731 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 8 Jul 2026 10:12:59 +0200 Subject: [PATCH 27/32] Fix the svcconf compobj svcconf must import the driver packages so they can register their keywords. Restricting the core keyword "stop_timeout" to the DEFAULT section made this latent issue appear, because the kw lookup failed even if the "stop_timeout" is actually in the container drivers manifest. --- util/compobj/svcconf.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/util/compobj/svcconf.go b/util/compobj/svcconf.go index aa5193e89..945b628f6 100644 --- a/util/compobj/svcconf.go +++ b/util/compobj/svcconf.go @@ -11,6 +11,8 @@ import ( "github.com/opensvc/om3/v3/core/naming" "github.com/opensvc/om3/v3/core/object" "github.com/opensvc/om3/v3/util/key" + + _ "github.com/opensvc/om3/v3/core/driverdb" ) type ( @@ -243,7 +245,8 @@ func (t CompSvcconfs) checkValue(resourceName string, keyName string, value stri if op == "unset" { return !o.Config().HasKey(key.New(resourceName, keyName)) } - return o.Config().HasKeyMatchingOp(*keyop.Parse(resourceName + "." + keyName + op + value)) + kop := keyop.Parse(resourceName + "." + keyName + op + value) + return o.Config().HasKeyMatchingOp(*kop) } func (t CompSvcconfs) checkSection(resourceName string, rule CompSvcconf) bool { From 017481ccb3e14a3a3d38a97f3f75e33f092b36d5 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 8 Jul 2026 11:18:40 +0200 Subject: [PATCH 28/32] Add goodies to the stressful CHANGELOG --- CHANGELOG.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index bccbb423a..c041f5a79 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,56 @@ max_delay = 10m # interpreted as 10m in om2 and om3 => Good ``` +## What's New in v3 + +OpenSVC v3 is a major evolution, rebuilt in Go for performance, reliability, and maintainability. Beyond the migration considerations, v3 introduces exciting new capabilities: + +### Architecture & Performance + +* **Complete Go rewrite**: The agent is now written in Go, delivering a compiled, statically-linked binary with improved performance, memory safety, and lower resource footprint compared to the Python v2 agent. + +* **Simplified deployment**: Single binary distribution with minimal dependencies. + +* **OpenAPI 3 based API**: Modern RESTful API with OpenAPI 3 specification, served over both Unix socket and inet, with bearer token authentication, replacing the custom raw JSON-RPC protocol. + +### User Experience + +* **New `ox` terminal UI**: A dedicated terminal interface for real-time cluster monitoring and management, complementing the `om` CLI. Open an `ox` session to watch services move around the cluster interactively. + +* **Enhanced logging with journald**: All agent logs now integrate with systemd-journald, enabling fast filtering with `journalctl _COMM=om` and adding indexed attributes like `OBJ_PATH` for precise log queries. + +### Orchestration & Management + +* **Live migration for KVM**: Full support for live migration of KVM instances with data on `disk.disk` and `disk.drbd` resources using `om switch --live` and `om takeover --live` commands. + +* **New placement policy**: `last start` policy uses the mtime of `/last_start` as the candidate sort key, with more recent starts having higher priority. + +* **Improved object labels**: Enhanced support for labeling objects, enabling better organization and selection. Labels help third-party solutions like backup tools, ingress gateways, and monitoring systems identify and handle objects appropriately. + +* **Better container management**: New commands for container operations including `om container ls`, `om container enter `, and `om container logs `. + +* **Task management**: New commands for task operations including `om task ls` and `om task run `. + +* **Resource group commands**: New per-driver-group command sets for more targeted resource management. + +### Configuration & Operations + +* **Unified configuration update**: The new `update` command with `--set`, `--unset`, and `--delete` flags allows atomic commits for different types of configuration changes. + +* **Quiet mode**: New `--quiet` flag for instance actions disables both progress rendering and console logging, useful for scripts and automation. + +* **Enhanced secret management**: New commands like `om key rename` for better key management in secret stores. + +### Network & Storage + +* **Modern firewall management**: Configuration now uses nftables exclusively, with better support for large subnets including IPv6 via the new `mask_per_node` keyword. + +* **Improved mount monitoring**: New daemon manager (`mntmon`) for monitoring mount events and refreshing instance status when mounts change. + +* **Network event handling**: New daemon network monitor (`netmon`) relays netlink events to pubsub, enabling faster response to network changes. + +* **New install keyword**: For fs and volume resources, the new `install` keyword enables deployment of complex file trees on start, with support for sec keys, cfg keys, local files or remote URIs, file/directory nesting, and user/group/permission setup. + ## Breaking Changes ### Cluster and Node Configuration From ab916cd58e567e93d81118546c48741e2dc727a5 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 8 Jul 2026 14:59:09 +0200 Subject: [PATCH 29/32] Add the "om svc|vol resource " commands And more actions in the per res-group commandsets: prstart, prstop, shutdown, startstandby. --- core/commoncmd/object.go | 19 +- core/om/factory.go | 986 ++++++++++++++++++++++++++++++++++++++- core/om/kind_svc.go | 43 +- core/om/kind_vol.go | 45 +- core/ox/factory.go | 418 +++++++++++++++++ core/ox/kind_svc.go | 14 +- core/ox/kind_vol.go | 32 ++ 7 files changed, 1527 insertions(+), 30 deletions(-) diff --git a/core/commoncmd/object.go b/core/commoncmd/object.go index 59f053d94..301d4b1f5 100644 --- a/core/commoncmd/object.go +++ b/core/commoncmd/object.go @@ -159,13 +159,30 @@ func NewCmdObjectInstanceSync(kind string) *cobra.Command { } } +func NewCmdObjectResourceSync(kind string) *cobra.Command { + cmd := &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "sync", + Short: "replicate object instance data", + } + cmd.AddGroup( + NewGroupSubsystems(), + ) + return cmd +} + func NewCmdObjectResource(kind string) *cobra.Command { - return &cobra.Command{ + cmd := &cobra.Command{ GroupID: GroupIDSubsystems, Use: "resource", Short: "list, start, stop, ...", Aliases: []string{"res"}, } + cmd.AddGroup( + NewGroupQuery(), + NewGroupSubsystems(), + ) + return cmd } func NewCmdObjectResourceInfo(kind string) *cobra.Command { diff --git a/core/om/factory.go b/core/om/factory.go index a77695526..92ec310e4 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -2477,6 +2477,119 @@ func newCmdObjectContainerUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectContainerStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a container resource in standby mode", + Long: "Start a container resource in standby mode. Specify a container ID as a positional argument. Equivalent to 'instance startstandby --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + return cmd +} + +func newCmdObjectContainerShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a container resource", + Long: "Shutdown a container resource. Specify a container ID as a positional argument. Equivalent to 'instance shutdown --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectContainerPRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a container resource", + Long: "Preempt devices exclusive write access reservation for a container resource. Specify a container ID as a positional argument. Equivalent to 'instance prstart --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectContainerPRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a container resource", + Long: "Release devices exclusive write access reservation for a container resource. Specify a container ID as a positional argument. Equivalent to 'instance prstop --rid container#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "container#" + args[0] + } else if options.RID == "" { + options.RID = "container" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectIPStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -2631,6 +2744,62 @@ func newCmdObjectIPUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectIPStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start an ip resource in standby mode", + Long: "Start an ip resource in standby mode. Specify an ip ID as a positional argument. Equivalent to 'instance startstandby --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + return cmd +} + +func newCmdObjectIPShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown an ip resource", + Long: "Shutdown an ip resource. Specify an ip ID as a positional argument. Equivalent to 'instance shutdown --rid ip#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "ip#" + args[0] + } else if options.RID == "" { + options.RID = "ip" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectFSStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -2662,6 +2831,115 @@ func newCmdObjectFSStart(kind string) *cobra.Command { return cmd } +func newCmdObjectFSStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a fs resource in standby mode", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + return cmd +} + +func newCmdObjectFSShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a fs resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectFSPRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a fs resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectFSPRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a fs resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } else if options.RID == "" { + options.RID = "fs" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectFSStop(kind string) *cobra.Command { var options commands.CmdObjectInstanceStop cmd := &cobra.Command{ @@ -2939,18 +3217,18 @@ func newCmdObjectVolumeUnprovision(kind string) *cobra.Command { return cmd } -func newCmdObjectDiskStart(kind string) *cobra.Command { - var options commands.CmdObjectInstanceStart +func newCmdObjectVolumeStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby cmd := &cobra.Command{ - Use: "start [ID]", - Short: "start a disk resource", - Long: "Start a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance start --rid disk#'.", + Use: "startstandby [ID]", + Short: "start a volume resource in standby mode", + Long: "Start a volume resource in standby mode. Specify a volume ID as a positional argument. Equivalent to 'instance startstandby --rid volume#'.", Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { - options.RID = "disk#" + args[0] + options.RID = "volume#" + args[0] } else if options.RID == "" { - options.RID = "disk" + options.RID = "volume" } return options.Run(kind) }, @@ -2965,12 +3243,128 @@ func newCmdObjectDiskStart(kind string) *cobra.Command { commoncmd.FlagForce(flags, &options.Force) commoncmd.FlagDisableRollback(flags, &options.DisableRollback) commoncmd.FlagNodeSelector(flags, &options.NodeSelector) - cmd.MarkFlagsMutuallyExclusive("no-lock", "node") - cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + hiddenFlagLocal(flags, &options.Local) return cmd } -func newCmdObjectDiskStop(kind string) *cobra.Command { +func newCmdObjectVolumeShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a volume resource", + Long: "Shutdown a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance shutdown --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectVolumePRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a volume resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectVolumePRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a volume resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } else if options.RID == "" { + options.RID = "volume" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectDiskStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start [ID]", + Short: "start a disk resource", + Long: "Start a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance start --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectDiskStop(kind string) *cobra.Command { var options commands.CmdObjectInstanceStop cmd := &cobra.Command{ Use: "stop [ID]", @@ -3093,6 +3487,122 @@ func newCmdObjectDiskUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectDiskStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a disk resource in standby mode", + Long: "Start a disk resource in standby mode. Specify a disk ID as a positional argument. Equivalent to 'instance startstandby --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectDiskShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a disk resource", + Long: "Shutdown a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance shutdown --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectDiskPRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a disk resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectDiskPRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a disk resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } else if options.RID == "" { + options.RID = "disk" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectShareStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -3247,6 +3757,65 @@ func newCmdObjectShareUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectShareStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a share resource in standby mode", + Long: "Start a share resource in standby mode. Specify a share ID as a positional argument. Equivalent to 'instance startstandby --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectShareShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a share resource", + Long: "Shutdown a share resource. Specify a share ID as a positional argument. Equivalent to 'instance shutdown --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } else if options.RID == "" { + options.RID = "share" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectAppStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -3302,19 +3871,78 @@ func newCmdObjectAppStop(kind string) *cobra.Command { commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) commoncmd.FlagsTo(flags, &options.OptTo) commoncmd.FlagForce(flags, &options.Force) - commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagMoveTo(flags, &options.MoveTo) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectAppRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart [ID]", + Short: "restart an app resource", + Long: "Restart an app resource. Specify an app ID as a positional argument. Equivalent to 'instance restart --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } else if options.RID == "" { + options.RID = "app" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + cmd.MarkFlagsMutuallyExclusive("no-lock", "node") + cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + return cmd +} + +func newCmdObjectAppShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown an app resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } else if options.RID == "" { + options.RID = "app" + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) commoncmd.FlagNodeSelector(flags, &options.NodeSelector) - cmd.MarkFlagsMutuallyExclusive("no-lock", "node") - cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + hiddenFlagLocal(flags, &options.Local) return cmd } -func newCmdObjectAppRestart(kind string) *cobra.Command { - var options commands.CmdObjectInstanceRestart +func newCmdObjectAppStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby cmd := &cobra.Command{ - Use: "restart [ID]", - Short: "restart an app resource", - Long: "Restart an app resource. Specify an app ID as a positional argument. Equivalent to 'instance restart --rid app#'.", + Use: "startstandby [ID]", + Short: "start a app resource in standby mode", + Long: "Start a app resource in standby mode. Specify a share ID as a positional argument. Equivalent to 'instance startstandby --rid app#'.", Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { if len(args) > 0 { @@ -3335,8 +3963,7 @@ func newCmdObjectAppRestart(kind string) *cobra.Command { commoncmd.FlagForce(flags, &options.Force) commoncmd.FlagDisableRollback(flags, &options.DisableRollback) commoncmd.FlagNodeSelector(flags, &options.NodeSelector) - cmd.MarkFlagsMutuallyExclusive("no-lock", "node") - cmd.MarkFlagsMutuallyExclusive("waitlock", "node") + hiddenFlagLocal(flags, &options.Local) return cmd } @@ -4341,6 +4968,323 @@ func newCmdObjectResourceList(kind string) *cobra.Command { return cmd } +func newCmdObjectResourceProvision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceProvision + cmd := &cobra.Command{ + Use: "provision ", + Short: "allocate the system resources of the instance resources", + Long: "Allocate the system resources required by the object instance resources identified by the rid selector.\n\nFor example, provision a fs.ext3 resource means format the device with the mkfs.ext3 command.", + Aliases: []string{"prov"}, + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagLeader(flags, &options.Leader) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.HiddenFlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagStateOnly(flags, &options.StateOnly) + return cmd +} + +func newCmdObjectResourceUnprovision(kind string) *cobra.Command { + var options commands.CmdObjectInstanceUnprovision + cmd := &cobra.Command{ + Use: "unprovision ", + Short: "deallocate the system resources of the instance resources", + Long: "Deallocate the system resources used by the object instance resources identified by the rid selector.", + Aliases: []string{"unprov"}, + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourcePRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart ", + Short: "preempt devices exclusive write access reservation", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + return cmd +} + +func newCmdObjectResourcePRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop ", + Short: "release devices exclusive write access reservation", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourceRestart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRestart + cmd := &cobra.Command{ + Use: "restart ", + Short: "restart the instance resources", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourceRun(kind string) *cobra.Command { + var options commands.CmdObjectInstanceRun + cmd := &cobra.Command{ + Use: "run ", + Short: "execute the instance resource run action", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourceStart(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStart + cmd := &cobra.Command{ + Use: "start ", + Short: "start the instance resources", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourceStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby ", + Short: "start the instance resources in standby mode", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourceStop(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStop + cmd := &cobra.Command{ + Use: "stop ", + Short: "stop the instance resources", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectResourceSync(kind string) *cobra.Command { + cmd := commoncmd.NewCmdObjectResourceSync(kind) + cmd.AddCommand( + newCmdObjectResourceSyncFull(kind), + newCmdObjectResourceSyncIngest(kind), + newCmdObjectResourceSyncResync(kind), + newCmdObjectResourceSyncSplit(kind), + newCmdObjectResourceSyncUpdate(kind), + ) + return cmd +} + +func newCmdObjectResourceSyncFull(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncFull + cmd := &cobra.Command{ + Use: "full ", + Short: "synchronize the copy of the local dataset on peers by sending the full data", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagTarget(flags, &options.Target) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectResourceSyncIngest(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncIngest + cmd := &cobra.Command{ + Use: "ingest ", + Short: "synchronize the copy of the local dataset on peers by receiving the full data", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectResourceSyncResync(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncResync + cmd := &cobra.Command{ + Use: "resync ", + Short: "synchronize the copy of the local dataset on peers by receiving incremental data", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagForce(flags, &options.Force) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + +func newCmdObjectResourceSyncSplit(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncSplit + cmd := &cobra.Command{ + Use: "split ", + Short: "change the sync peer list", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsLock(flags, &options.OptsLock) + return cmd +} + +func newCmdObjectResourceSyncUpdate(kind string) *cobra.Command { + var options commands.CmdObjectInstanceSyncUpdate + cmd := &cobra.Command{ + Use: "update ", + Short: "synchronize the copy of the local dataset on peers", + Long: "Synchronize the copy of the local dataset on peers for the instance resource identified by the rid selector. This update can use either full or incremental copy, depending on the resource drivers and host capabilities.", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + options.OptsResourceSelector.RID = args[0] + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagTarget(flags, &options.Target) + hiddenFlagLocal(flags, &options.Local) + return cmd +} + func newCmdObjectSetProvisioned(kind string) *cobra.Command { var options commands.CmdObjectInstanceProvision cmd := &cobra.Command{ @@ -4399,8 +5343,8 @@ func newCmdObjectInstanceShutdown(kind string) *cobra.Command { flags := cmd.Flags() addFlagsGlobal(flags, &options.OptsGlobal) commoncmd.FlagsAsync(flags, &options.OptsAsync) - commoncmd.FlagsLock(flags, &options.OptsLock) commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsLock(flags, &options.OptsLock) commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) commoncmd.FlagsTo(flags, &options.OptTo) commoncmd.FlagForce(flags, &options.Force) diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index 952c21f6e..607c927dc 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -38,6 +38,7 @@ func init() { cmdObjectPush := newCmdObjectPush(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) + cmdObjectResourceSync := newCmdObjectResourceSync(kind) cmdObjectSchedule := commoncmd.NewCmdObjectSchedule(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectSync := commoncmd.NewCmdObjectSync(kind) @@ -121,7 +122,11 @@ func init() { newCmdObjectContainerEnter(kind), newCmdObjectContainerLogs(kind), newCmdObjectContainerList(kind), + newCmdObjectContainerPRStart(kind), + newCmdObjectContainerPRStop(kind), newCmdObjectContainerStart(kind), + newCmdObjectContainerStartStandby(kind), + newCmdObjectContainerShutdown(kind), newCmdObjectContainerStop(kind), newCmdObjectContainerRestart(kind), newCmdObjectContainerProvision(kind), @@ -130,6 +135,8 @@ func init() { cmdObjectIP.AddCommand( newCmdObjectIPList(kind), newCmdObjectIPStart(kind), + newCmdObjectIPStartStandby(kind), + newCmdObjectIPShutdown(kind), newCmdObjectIPStop(kind), newCmdObjectIPRestart(kind), newCmdObjectIPProvision(kind), @@ -137,31 +144,45 @@ func init() { ) cmdObjectFS.AddCommand( newCmdObjectFSList(kind), + newCmdObjectFSProvision(kind), + newCmdObjectFSPRStart(kind), + newCmdObjectFSPRStop(kind), + newCmdObjectFSRestart(kind), + newCmdObjectFSShutdown(kind), newCmdObjectFSStart(kind), + newCmdObjectFSStartStandby(kind), newCmdObjectFSStop(kind), - newCmdObjectFSRestart(kind), - newCmdObjectFSProvision(kind), newCmdObjectFSUnprovision(kind), ) cmdObjectVolume.AddCommand( newCmdObjectVolumeList(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumePRStart(kind), + newCmdObjectVolumePRStop(kind), + newCmdObjectVolumeRestart(kind), + newCmdObjectVolumeShutdown(kind), newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStartStandby(kind), newCmdObjectVolumeStop(kind), - newCmdObjectVolumeRestart(kind), - newCmdObjectVolumeProvision(kind), newCmdObjectVolumeUnprovision(kind), ) cmdObjectDisk.AddCommand( newCmdObjectDiskList(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskPRStart(kind), + newCmdObjectDiskPRStop(kind), + newCmdObjectDiskShutdown(kind), newCmdObjectDiskStart(kind), + newCmdObjectDiskStartStandby(kind), newCmdObjectDiskStop(kind), newCmdObjectDiskRestart(kind), - newCmdObjectDiskProvision(kind), newCmdObjectDiskUnprovision(kind), ) cmdObjectShare.AddCommand( newCmdObjectShareList(kind), + newCmdObjectShareShutdown(kind), newCmdObjectShareStart(kind), + newCmdObjectShareStartStandby(kind), newCmdObjectShareStop(kind), newCmdObjectShareRestart(kind), newCmdObjectShareProvision(kind), @@ -170,7 +191,9 @@ func init() { cmdObjectApp.AddCommand( newCmdObjectAppList(kind), newCmdObjectAppRestart(kind), + newCmdObjectAppShutdown(kind), newCmdObjectAppStart(kind), + newCmdObjectAppStartStandby(kind), newCmdObjectAppStop(kind), ) cmdObjectTask.AddCommand( @@ -186,6 +209,16 @@ func init() { cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), cmdObjectResourceInfo, + cmdObjectResourceSync, + newCmdObjectResourceProvision(kind), + newCmdObjectResourceUnprovision(kind), + newCmdObjectResourcePRStart(kind), + newCmdObjectResourcePRStop(kind), + newCmdObjectResourceRestart(kind), + newCmdObjectResourceRun(kind), + newCmdObjectResourceStart(kind), + newCmdObjectResourceStartStandby(kind), + newCmdObjectResourceStop(kind), ) cmdObjectInstance.AddCommand( cmdObjectInstanceDevice, diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index f764277fb..d6a54a74f 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -16,6 +16,7 @@ func init() { cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) + cmdObjectFS := commoncmd.NewCmdObjectFS(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) cmdObjectInstanceDevice := commoncmd.NewCmdObjectInstanceDevice(kind) cmdObjectInstancePG := commoncmd.NewCmdObjectInstancePG(kind) @@ -27,6 +28,7 @@ func init() { cmdObjectPush := newCmdObjectPush(kind) cmdObjectResource := commoncmd.NewCmdObjectResource(kind) cmdObjectResourceInfo := commoncmd.NewCmdObjectResourceInfo(kind) + cmdObjectResourceSync := newCmdObjectResourceSync(kind) cmdObjectSchedule := commoncmd.NewCmdObjectSchedule(kind) cmdObjectSet := newCmdObjectSet(kind) cmdObjectSync := commoncmd.NewCmdObjectSync(kind) @@ -44,7 +46,7 @@ func init() { cmdObject.AddCommand( cmdObjectCollector, cmdObjectConfig, - cmdObjectVolume, + cmdObjectFS, cmdObjectDisk, cmdObjectEdit, cmdObjectInstance, @@ -56,6 +58,7 @@ func init() { cmdObjectSchedule, cmdObjectSync, cmdObjectValidate, + cmdObjectVolume, newCmdObjectAbort(kind), commoncmd.NewCmdObjectClear(kind), newCmdObjectCreate(kind), @@ -86,11 +89,41 @@ func init() { newCmdObjectUnprovision(kind), newCmdObjectUnset(kind), ) + cmdObjectFS.AddCommand( + newCmdObjectFSList(kind), + newCmdObjectFSProvision(kind), + newCmdObjectFSPRStart(kind), + newCmdObjectFSPRStop(kind), + newCmdObjectFSRestart(kind), + newCmdObjectFSShutdown(kind), + newCmdObjectFSStart(kind), + newCmdObjectFSStartStandby(kind), + newCmdObjectFSStop(kind), + newCmdObjectFSUnprovision(kind), + ) cmdObjectVolume.AddCommand( newCmdObjectVolumeList(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumePRStart(kind), + newCmdObjectVolumePRStop(kind), + newCmdObjectVolumeRestart(kind), + newCmdObjectVolumeShutdown(kind), + newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStartStandby(kind), + newCmdObjectVolumeStop(kind), + newCmdObjectVolumeUnprovision(kind), ) cmdObjectDisk.AddCommand( newCmdObjectDiskList(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskPRStart(kind), + newCmdObjectDiskPRStop(kind), + newCmdObjectDiskShutdown(kind), + newCmdObjectDiskStart(kind), + newCmdObjectDiskStartStandby(kind), + newCmdObjectDiskStop(kind), + newCmdObjectDiskRestart(kind), + newCmdObjectDiskUnprovision(kind), ) cmdObjectCollector.AddCommand( cmdObjectCollectorTag, @@ -153,6 +186,16 @@ func init() { cmdObjectResource.AddCommand( newCmdObjectResourceList(kind), cmdObjectResourceInfo, + cmdObjectResourceSync, + newCmdObjectResourceProvision(kind), + newCmdObjectResourceUnprovision(kind), + newCmdObjectResourcePRStart(kind), + newCmdObjectResourcePRStop(kind), + newCmdObjectResourceRestart(kind), + newCmdObjectResourceRun(kind), + newCmdObjectResourceStart(kind), + newCmdObjectResourceStartStandby(kind), + newCmdObjectResourceStop(kind), ) cmdObjectResourceInfo.AddCommand( newCmdObjectResourceInfoList(kind), diff --git a/core/ox/factory.go b/core/ox/factory.go index 11138132f..14f90f45c 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -2543,6 +2543,110 @@ func newCmdObjectFSUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectFSPRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a fs resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectFSPRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a fs resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectFSShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a fs resource", + Long: "Shutdown a fs resource. Specify a fs ID as a positional argument. Equivalent to 'instance shutdown --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectFSStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a fs resource in standby mode", + Long: "Start a fs resource in standby mode. Specify a fs ID as a positional argument. Equivalent to 'instance startstandby --rid fs#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "fs#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectVolumeStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -2687,6 +2791,110 @@ func newCmdObjectVolumeUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectVolumePRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a volume resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectVolumePRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a volume resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectVolumeShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a volume resource", + Long: "Shutdown a volume resource. Specify a volume ID as a positional argument. Equivalent to 'instance shutdown --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectVolumeStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a volume resource in standby mode", + Long: "Start a volume resource in standby mode. Specify a volume ID as a positional argument. Equivalent to 'instance startstandby --rid volume#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "volume#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectDiskStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -2831,6 +3039,110 @@ func newCmdObjectDiskUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectDiskPRStart(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStart + cmd := &cobra.Command{ + Use: "prstart [ID]", + Short: "preempt devices exclusive write access reservation for a disk resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDiskPRStop(kind string) *cobra.Command { + var options commands.CmdObjectInstancePRStop + cmd := &cobra.Command{ + Use: "prstop [ID]", + Short: "release devices exclusive write access reservation for a disk resource", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDiskShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a disk resource", + Long: "Shutdown a disk resource. Specify a disk ID as a positional argument. Equivalent to 'instance shutdown --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectDiskStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a disk resource in standby mode", + Long: "Start a disk resource in standby mode. Specify a disk ID as a positional argument. Equivalent to 'instance startstandby --rid disk#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "disk#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectShareStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -2975,6 +3287,59 @@ func newCmdObjectShareUnprovision(kind string) *cobra.Command { return cmd } +func newCmdObjectShareShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown a share resource", + Long: "Shutdown a share resource. Specify a share ID as a positional argument. Equivalent to 'instance shutdown --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectShareStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start a share resource in standby mode", + Long: "Start a share resource in standby mode. Specify a share ID as a positional argument. Equivalent to 'instance startstandby --rid share#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "share#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectAppStart(kind string) *cobra.Command { var options commands.CmdObjectInstanceStart cmd := &cobra.Command{ @@ -3062,6 +3427,59 @@ func newCmdObjectAppRestart(kind string) *cobra.Command { return cmd } +func newCmdObjectAppShutdown(kind string) *cobra.Command { + var options commands.CmdObjectInstanceShutdown + cmd := &cobra.Command{ + Use: "shutdown [ID]", + Short: "shutdown an app resource", + Long: "Shutdown an app resource. Specify an app ID as a positional argument. Equivalent to 'instance shutdown --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + +func newCmdObjectAppStartStandby(kind string) *cobra.Command { + var options commands.CmdObjectInstanceStartStandby + cmd := &cobra.Command{ + Use: "startstandby [ID]", + Short: "start an app resource in standby mode", + Long: "Start an app resource in standby mode. Specify an app ID as a positional argument. Equivalent to 'instance startstandby --rid app#'.", + Args: cobra.MaximumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + options.RID = "app#" + args[0] + } + return options.Run(kind) + }, + } + flags := cmd.Flags() + addFlagsGlobal(flags, &options.OptsGlobal) + commoncmd.FlagsAsync(flags, &options.OptsAsync) + commoncmd.FlagsLock(flags, &options.OptsLock) + commoncmd.FlagsEncap(flags, &options.OptsEncap) + commoncmd.FlagsResourceSelector(cmd, &options.OptsResourceSelector) + commoncmd.FlagsTo(flags, &options.OptTo) + commoncmd.FlagForce(flags, &options.Force) + commoncmd.FlagDisableRollback(flags, &options.DisableRollback) + commoncmd.FlagNodeSelector(flags, &options.NodeSelector) + return cmd +} + func newCmdObjectTaskRun(kind string) *cobra.Command { var options commands.CmdObjectInstanceRun cmd := &cobra.Command{ diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 38fb775aa..291f0a322 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -138,23 +138,31 @@ func init() { ) cmdObjectVolume.AddCommand( newCmdObjectVolumeList(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumeShutdown(kind), newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStartStandby(kind), newCmdObjectVolumeStop(kind), newCmdObjectVolumeRestart(kind), - newCmdObjectVolumeProvision(kind), newCmdObjectVolumeUnprovision(kind), ) cmdObjectDisk.AddCommand( newCmdObjectDiskList(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskPRStart(kind), + newCmdObjectDiskShutdown(kind), + newCmdObjectDiskPRStop(kind), newCmdObjectDiskStart(kind), + newCmdObjectDiskStartStandby(kind), newCmdObjectDiskStop(kind), newCmdObjectDiskRestart(kind), - newCmdObjectDiskProvision(kind), newCmdObjectDiskUnprovision(kind), ) cmdObjectShare.AddCommand( newCmdObjectShareList(kind), + newCmdObjectShareShutdown(kind), newCmdObjectShareStart(kind), + newCmdObjectShareStartStandby(kind), newCmdObjectShareStop(kind), newCmdObjectShareRestart(kind), newCmdObjectShareProvision(kind), @@ -162,7 +170,9 @@ func init() { ) cmdObjectApp.AddCommand( newCmdObjectAppList(kind), + newCmdObjectAppShutdown(kind), newCmdObjectAppStart(kind), + newCmdObjectAppStartStandby(kind), newCmdObjectAppStop(kind), newCmdObjectAppRestart(kind), ) diff --git a/core/ox/kind_vol.go b/core/ox/kind_vol.go index f5dc8c505..72d3f0f61 100644 --- a/core/ox/kind_vol.go +++ b/core/ox/kind_vol.go @@ -9,6 +9,7 @@ func init() { cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) + cmdObjectFS := commoncmd.NewCmdObjectFS(kind) cmdObjectVolume := commoncmd.NewCmdObjectVolume(kind) cmdObjectDisk := commoncmd.NewCmdObjectDisk(kind) cmdObjectEdit := newCmdObjectEdit(kind) @@ -39,6 +40,7 @@ func init() { cmdObject.AddCommand( cmdObjectCollector, cmdObjectConfig, + cmdObjectFS, cmdObjectVolume, cmdObjectDisk, cmdObjectEdit, @@ -78,11 +80,41 @@ func init() { newCmdObjectUpdate(kind), newCmdTUI(kind), ) + cmdObjectFS.AddCommand( + newCmdObjectFSList(kind), + newCmdObjectFSProvision(kind), + newCmdObjectFSPRStart(kind), + newCmdObjectFSPRStop(kind), + newCmdObjectFSRestart(kind), + newCmdObjectFSShutdown(kind), + newCmdObjectFSStart(kind), + newCmdObjectFSStartStandby(kind), + newCmdObjectFSStop(kind), + newCmdObjectFSUnprovision(kind), + ) cmdObjectVolume.AddCommand( newCmdObjectVolumeList(kind), + newCmdObjectVolumeProvision(kind), + newCmdObjectVolumePRStart(kind), + newCmdObjectVolumePRStop(kind), + newCmdObjectVolumeRestart(kind), + newCmdObjectVolumeShutdown(kind), + newCmdObjectVolumeStart(kind), + newCmdObjectVolumeStartStandby(kind), + newCmdObjectVolumeStop(kind), + newCmdObjectVolumeUnprovision(kind), ) cmdObjectDisk.AddCommand( newCmdObjectDiskList(kind), + newCmdObjectDiskProvision(kind), + newCmdObjectDiskPRStart(kind), + newCmdObjectDiskPRStop(kind), + newCmdObjectDiskShutdown(kind), + newCmdObjectDiskStart(kind), + newCmdObjectDiskStartStandby(kind), + newCmdObjectDiskStop(kind), + newCmdObjectDiskRestart(kind), + newCmdObjectDiskUnprovision(kind), ) cmdObjectCollector.AddCommand( cmdObjectCollectorTag, From d396c673fd22da90e60f52c2a96e99911dd4457b Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 8 Jul 2026 22:04:10 +0200 Subject: [PATCH 30/32] Factorize more core/o[mx] code into commoncmd * global flags * per-kind cobra command factory funcs --- core/commoncmd/factory_kind.go | 113 +++++++++++++++++++++++++++++++++ core/commoncmd/flags_global.go | 26 ++++++++ core/commoncmd/main.go | 1 + core/om/factory.go | 105 ------------------------------ core/om/flags.go | 5 +- core/om/kind_all.go | 2 +- core/om/kind_ccfg.go | 2 +- core/om/kind_cfg.go | 2 +- core/om/kind_sec.go | 2 +- core/om/kind_svc.go | 2 +- core/om/kind_usr.go | 2 +- core/om/kind_vol.go | 2 +- core/omcmd/options.go | 7 +- core/ox/factory.go | 105 ------------------------------ core/ox/flags.go | 5 +- core/ox/kind_all.go | 2 +- core/ox/kind_ccfg.go | 2 +- core/ox/kind_cfg.go | 2 +- core/ox/kind_sec.go | 2 +- core/ox/kind_svc.go | 2 +- core/ox/kind_usr.go | 2 +- core/ox/kind_vol.go | 2 +- core/oxcmd/options.go | 7 +- 23 files changed, 162 insertions(+), 240 deletions(-) create mode 100644 core/commoncmd/factory_kind.go create mode 100644 core/commoncmd/flags_global.go diff --git a/core/commoncmd/factory_kind.go b/core/commoncmd/factory_kind.go new file mode 100644 index 000000000..c0e4ba70b --- /dev/null +++ b/core/commoncmd/factory_kind.go @@ -0,0 +1,113 @@ +package commoncmd + +import ( + "github.com/spf13/cobra" +) + +// NewCmdAll creates the "all" command +func NewCmdAll() *cobra.Command { + return &cobra.Command{ + Use: "all", + Short: "manage a mix of objects, tentatively exposing all commands", + } +} + +// NewCmdCcfg creates the "ccfg" command +func NewCmdCcfg() *cobra.Command { + return &cobra.Command{ + Use: "ccfg", + Short: "manage the cluster shared configuration", + Long: `The cluster nodes merge their private configuration +over the cluster shared configuration. + +The shared configuration is hosted in a ccfg-kind object, and is +replicated using the same rules as other kinds of object (last write is +eventually replicated).`, + } +} + +// NewCmdCfg creates the "cfg" command +func NewCmdCfg() *cobra.Command { + return &cobra.Command{ + Use: "cfg", + Short: "manage configmaps", + Long: `A configmap is an unencrypted key-value store. + +Values can be binary or text. + +A key can be installed as a file in a Vol, then exposed to apps +and containers. + +A key can be exposed as a environment variable for apps and +containers. + +A signal can be sent to consumer processes upon exposed key value +changes. + +The key names can include the '/' character, interpreted as a path separator +when installing the key in a volume.`, + } +} + +// NewCmdSec creates the "sec" command +func NewCmdSec() *cobra.Command { + return &cobra.Command{ + Use: "sec", + Short: "manage secrets", + Long: `A secret is an encrypted key-value store. + +Values can be binary or text. + +A key can be installed as a file in a Vol, then exposed to apps +and containers. + +A key can be exposed as a environment variable for apps and +containers. + +A signal can be sent to consumer processes upon exposed key value +changes. + +The key names can include the '/' character, interpreted as a path separator +when installing the key in a volume.`, + } +} + +// NewCmdSVC creates the "svc" command +func NewCmdSVC() *cobra.Command { + return &cobra.Command{ + Use: "svc", + Short: "manage services", + Long: `Service objects subsystem. + +A service is typically made of ip, app, container and task resources. + +They can use support objects like volumes, secrets and configmaps to +isolate lifecycles or to abstract cluster-specific knowledge.`, + } +} + +// NewCmdUsr creates the "usr" command +func NewCmdUsr() *cobra.Command { + return &cobra.Command{ + Use: "usr", + Short: "manage users", + Long: `A user stores the grants and credentials of user of the agent API. + +User objects are not necessary with OpenID authentication, as the +grants are embedded in the trusted bearer tokens.`, + } +} + +// NewCmdVol creates the "vol" command +func NewCmdVol() *cobra.Command { + return &cobra.Command{ + Use: "vol", + Short: "manage volumes", + Long: `A volume is a persistent data provider. + +A volume is made of disk, fs and sync resources. It is created by a pool, +to satisfy a demand from a volume resource in a service. + +Volumes and their subdirectories can be mounted inside containers.`, + } +} diff --git a/core/commoncmd/flags_global.go b/core/commoncmd/flags_global.go new file mode 100644 index 000000000..42aac9bb8 --- /dev/null +++ b/core/commoncmd/flags_global.go @@ -0,0 +1,26 @@ +package commoncmd + +import ( + "github.com/spf13/pflag" +) + +// AddFlagsGlobal adds the global flags to the flag set. +// This is the common implementation used by both om and ox. +func AddFlagsGlobal(flags *pflag.FlagSet, p *OptsGlobal) { + FlagColor(flags, &p.Color) + FlagOutput(flags, &p.Output) + FlagObjectSelector(flags, &p.ObjectSelector) + FlagIgnoreNotFound(flags, &p.IgnoreNotFound) +} + +// AddFlagsGlobalWithColorOutput adds color and output flags +func AddFlagsGlobalWithColorOutput(flags *pflag.FlagSet, color, output *string) { + FlagColor(flags, color) + FlagOutput(flags, output) +} + +// AddFlagsGlobalWithSelector adds object selector and ignore not found flags +func AddFlagsGlobalWithSelector(flags *pflag.FlagSet, objectSelector *string, ignoreNotFound *bool) { + FlagObjectSelector(flags, objectSelector) + FlagIgnoreNotFound(flags, ignoreNotFound) +} \ No newline at end of file diff --git a/core/commoncmd/main.go b/core/commoncmd/main.go index 4af898f75..214b77856 100644 --- a/core/commoncmd/main.go +++ b/core/commoncmd/main.go @@ -30,6 +30,7 @@ type ( Color string Output string ObjectSelector string + IgnoreNotFound bool } OptsNodeGlobal struct { diff --git a/core/om/factory.go b/core/om/factory.go index 92ec310e4..88e86e622 100644 --- a/core/om/factory.go +++ b/core/om/factory.go @@ -14,111 +14,6 @@ import ( "github.com/opensvc/om3/v3/util/hostname" ) -func newCmdAll() *cobra.Command { - return &cobra.Command{ - Use: "all", - Short: "manage a mix of objects, tentatively exposing all commands", - } -} - -func newCmdCcfg() *cobra.Command { - return &cobra.Command{ - Use: "ccfg", - Short: "manage the cluster shared configuration", - Long: `The cluster nodes merge their private configuration -over the cluster shared configuration. - -The shared configuration is hosted in a ccfg-kind object, and is -replicated using the same rules as other kinds of object (last write is -eventually replicated). -`, - } -} - -func newCmdCfg() *cobra.Command { - return &cobra.Command{ - Use: "cfg", - Short: "manage configmaps", - Long: `A configmap is an unencrypted key-value store. - -Values can be binary or text. - -A key can be installed as a file in a Vol, then exposed to apps -and containers. - -A key can be exposed as a environment variable for apps and -containers. - -A signal can be sent to consumer processes upon exposed key value -changes. - -The key names can include the '/' character, interpreted as a path separator -when installing the key in a volume.`, - } -} - -func newCmdSec() *cobra.Command { - return &cobra.Command{ - Use: "sec", - Short: "manage secrets", - Long: `A secret is an encrypted key-value store. - -Values can be binary or text. - -A key can be installed as a file in a Vol, then exposed to apps -and containers. - -A key can be exposed as a environment variable for apps and -containers. - -A signal can be sent to consumer processes upon exposed key value -changes. - -The key names can include the '/' character, interpreted as a path separator -when installing the key in a volume.`, - } -} - -func newCmdSVC() *cobra.Command { - return &cobra.Command{ - Use: "svc", - Short: "manage services", - Long: `Service objects subsystem. - -A service is typically made of ip, app, container and task resources. - -They can use support objects like volumes, secrets and configmaps to -isolate lifecycles or to abstract cluster-specific knowledge. -`, - } -} - -func newCmdVol() *cobra.Command { - return &cobra.Command{ - Use: "vol", - Short: "manage volumes", - Long: `A volume is a persistent data provider. - -A volume is made of disk, fs and sync resources. It is created by a pool, -to satisfy a demand from a volume resource in a service. - -Volumes and their subdirectories can be mounted inside containers. - -A volume can host cfg and sec keys projections.`, - } -} - -func newCmdUsr() *cobra.Command { - return &cobra.Command{ - Use: "usr", - Short: "manage users", - Long: `A user stores the grants and credentials of user of the agent API. - -User objects are not necessary with OpenID authentication, as the -grants are embedded in the trusted bearer tokens.`, - } -} - func newCmdArrayList() *cobra.Command { var options commands.CmdArrayList cmd := &cobra.Command{ diff --git a/core/om/flags.go b/core/om/flags.go index 4905fcda1..a7bf4647d 100644 --- a/core/om/flags.go +++ b/core/om/flags.go @@ -11,10 +11,7 @@ import ( ) func addFlagsGlobal(flags *pflag.FlagSet, options *commands.OptsGlobal) { - commoncmd.FlagColor(flags, &options.Color) - commoncmd.FlagOutput(flags, &options.Output) - commoncmd.FlagObjectSelector(flags, &options.ObjectSelector) - commoncmd.FlagIgnoreNotFound(flags, &options.IgnoreNotFound) + commoncmd.AddFlagsGlobal(flags, &options.OptsGlobal) } func flagLocal(flags *pflag.FlagSet, p *bool) { diff --git a/core/om/kind_all.go b/core/om/kind_all.go index a467a8ead..6014a16cf 100644 --- a/core/om/kind_all.go +++ b/core/om/kind_all.go @@ -8,7 +8,7 @@ import ( func init() { kind := "" - cmdObject := newCmdAll() + cmdObject := commoncmd.NewCmdAll() cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectCompliance := commoncmd.NewCmdObjectCompliance(kind) diff --git a/core/om/kind_ccfg.go b/core/om/kind_ccfg.go index 8ac375cc7..32c701cbc 100644 --- a/core/om/kind_ccfg.go +++ b/core/om/kind_ccfg.go @@ -8,7 +8,7 @@ import ( func init() { kind := "ccfg" - cmdObject := newCmdCcfg() + cmdObject := commoncmd.NewCmdCcfg() cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectSet := newCmdObjectSet(kind) diff --git a/core/om/kind_cfg.go b/core/om/kind_cfg.go index e64e3a12f..775514681 100644 --- a/core/om/kind_cfg.go +++ b/core/om/kind_cfg.go @@ -8,7 +8,7 @@ import ( func init() { kind := "cfg" - cmdObject := newCmdCfg() + cmdObject := commoncmd.NewCmdCfg() cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectKey := commoncmd.NewCmdObjectKey(kind) diff --git a/core/om/kind_sec.go b/core/om/kind_sec.go index 8374dadd0..dbb4af475 100644 --- a/core/om/kind_sec.go +++ b/core/om/kind_sec.go @@ -8,7 +8,7 @@ import ( func init() { kind := "sec" - cmdObject := newCmdSec() + cmdObject := commoncmd.NewCmdSec() cmdObjectCertificate := newCmdObjectCertificate(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) diff --git a/core/om/kind_svc.go b/core/om/kind_svc.go index 607c927dc..aeedcddef 100644 --- a/core/om/kind_svc.go +++ b/core/om/kind_svc.go @@ -9,7 +9,7 @@ import ( func init() { kind := "svc" - cmdObject := newCmdSVC() + cmdObject := commoncmd.NewCmdSVC() cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectCompliance := commoncmd.NewCmdObjectCompliance(kind) diff --git a/core/om/kind_usr.go b/core/om/kind_usr.go index 6049d13d5..50e6bc7da 100644 --- a/core/om/kind_usr.go +++ b/core/om/kind_usr.go @@ -8,7 +8,7 @@ import ( func init() { kind := "usr" - cmdObject := newCmdUsr() + cmdObject := commoncmd.NewCmdUsr() cmdObjectCertificate := newCmdObjectCertificate(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) diff --git a/core/om/kind_vol.go b/core/om/kind_vol.go index d6a54a74f..017b4bd35 100644 --- a/core/om/kind_vol.go +++ b/core/om/kind_vol.go @@ -9,7 +9,7 @@ import ( func init() { kind := "vol" - cmdObject := newCmdVol() + cmdObject := commoncmd.NewCmdVol() cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectEdit := newCmdObjectEdit(kind) diff --git a/core/omcmd/options.go b/core/omcmd/options.go index 9be4db91b..d24a5078e 100644 --- a/core/omcmd/options.go +++ b/core/omcmd/options.go @@ -1,11 +1,10 @@ package omcmd +import "github.com/opensvc/om3/v3/core/commoncmd" + type ( // OptsGlobal contains options accepted by all actions OptsGlobal struct { - Color string - Output string - ObjectSelector string - IgnoreNotFound bool + commoncmd.OptsGlobal } ) diff --git a/core/ox/factory.go b/core/ox/factory.go index 14f90f45c..b2b742b4c 100644 --- a/core/ox/factory.go +++ b/core/ox/factory.go @@ -11,111 +11,6 @@ import ( "github.com/opensvc/om3/v3/core/tui" ) -func newCmdAll() *cobra.Command { - return &cobra.Command{ - Use: "all", - Short: "manage a mix of objects, tentatively exposing all commands", - } -} - -func newCmdCcfg() *cobra.Command { - return &cobra.Command{ - Use: "ccfg", - Short: "manage the cluster shared configuration", - Long: `The cluster nodes merge their private configuration -over the cluster shared configuration. - -The shared configuration is hosted in a ccfg-kind object, and is -replicated using the same rules as other kinds of object (last write is -eventually replicated). -`, - } -} - -func newCmdCfg() *cobra.Command { - return &cobra.Command{ - Use: "cfg", - Short: "manage configmaps", - Long: `A configmap is an unencrypted key-value store. - -Values can be binary or text. - -A key can be installed as a file in a Vol, then exposed to apps -and containers. - -A key can be exposed as a environment variable for apps and -containers. - -A signal can be sent to consumer processes upon exposed key value -changes. - -The key names can include the '/' character, interpreted as a path separator -when installing the key in a volume.`, - } -} - -func newCmdSec() *cobra.Command { - return &cobra.Command{ - Use: "sec", - Short: "manage secrets", - Long: `A secret is an encrypted key-value store. - -Values can be binary or text. - -A key can be installed as a file in a Vol, then exposed to apps -and containers. - -A key can be exposed as a environment variable for apps and -containers. - -A signal can be sent to consumer processes upon exposed key value -changes. - -The key names can include the '/' character, interpreted as a path separator -when installing the key in a volume.`, - } -} - -func newCmdSVC() *cobra.Command { - return &cobra.Command{ - Use: "svc", - Short: "manage services", - Long: `Service objects subsystem. - -A service is typically made of ip, app, container and task resources. - -They can use support objects like volumes, secrets and configmaps to -isolate lifecycles or to abstract cluster-specific knowledge. -`, - } -} - -func newCmdVol() *cobra.Command { - return &cobra.Command{ - Use: "vol", - Short: "manage volumes", - Long: `A volume is a persistent data provider. - -A volume is made of disk, fs and sync resources. It is created by a pool, -to satisfy a demand from a volume resource in a service. - -Volumes and their subdirectories can be mounted inside containers. - -A volume can host cfg and sec keys projections.`, - } -} - -func newCmdUsr() *cobra.Command { - return &cobra.Command{ - Use: "usr", - Short: "manage users", - Long: `A user stores the grants and credentials of user of the agent API. - -User objects are not necessary with OpenID authentication, as the -grants are embedded in the trusted bearer tokens.`, - } -} - func newCmdArrayList() *cobra.Command { var options commands.CmdArrayList cmd := &cobra.Command{ diff --git a/core/ox/flags.go b/core/ox/flags.go index 4fa81d957..94902dca1 100644 --- a/core/ox/flags.go +++ b/core/ox/flags.go @@ -11,10 +11,7 @@ import ( ) func addFlagsGlobal(flagSet *pflag.FlagSet, p *commands.OptsGlobal) { - flagSet.StringVar(&p.Color, "color", "auto", "output colorization yes|no|auto") - flagSet.StringVarP(&p.Output, "output", "o", "auto", "output format json|flat|auto|tab=
:,...") - flagSet.StringVarP(&p.ObjectSelector, "selector", "s", "", "execute on a list of objects") - commoncmd.FlagIgnoreNotFound(flagSet, &p.IgnoreNotFound) + commoncmd.AddFlagsGlobal(flagSet, &p.OptsGlobal) } func addFlagObject(flagSet *pflag.FlagSet, p *string) { diff --git a/core/ox/kind_all.go b/core/ox/kind_all.go index 03829cc8a..e40547f19 100644 --- a/core/ox/kind_all.go +++ b/core/ox/kind_all.go @@ -4,7 +4,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "" - cmdObject := newCmdAll() + cmdObject := commoncmd.NewCmdAll() cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectCompliance := commoncmd.NewCmdObjectCompliance(kind) diff --git a/core/ox/kind_ccfg.go b/core/ox/kind_ccfg.go index f42ab83e2..f3e6655ae 100644 --- a/core/ox/kind_ccfg.go +++ b/core/ox/kind_ccfg.go @@ -5,7 +5,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "ccfg" - cmdObject := newCmdCcfg() + cmdObject := commoncmd.NewCmdCcfg() cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectSet := newCmdObjectSet(kind) diff --git a/core/ox/kind_cfg.go b/core/ox/kind_cfg.go index 87ab60698..4eca391d0 100644 --- a/core/ox/kind_cfg.go +++ b/core/ox/kind_cfg.go @@ -5,7 +5,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "cfg" - cmdObject := newCmdCfg() + cmdObject := commoncmd.NewCmdCfg() cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectKey := commoncmd.NewCmdObjectKey(kind) diff --git a/core/ox/kind_sec.go b/core/ox/kind_sec.go index f0c358750..6dc31bac6 100644 --- a/core/ox/kind_sec.go +++ b/core/ox/kind_sec.go @@ -5,7 +5,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "sec" - cmdObject := newCmdSec() + cmdObject := commoncmd.NewCmdSec() cmdObjectCertificate := newCmdObjectCertificate(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) diff --git a/core/ox/kind_svc.go b/core/ox/kind_svc.go index 291f0a322..12965e396 100644 --- a/core/ox/kind_svc.go +++ b/core/ox/kind_svc.go @@ -5,7 +5,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "svc" - cmdObject := newCmdSVC() + cmdObject := commoncmd.NewCmdSVC() cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectCompliance := commoncmd.NewCmdObjectCompliance(kind) diff --git a/core/ox/kind_usr.go b/core/ox/kind_usr.go index 3c070e040..b1181383d 100644 --- a/core/ox/kind_usr.go +++ b/core/ox/kind_usr.go @@ -5,7 +5,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "usr" - cmdObject := newCmdUsr() + cmdObject := commoncmd.NewCmdUsr() cmdObjectCertificate := newCmdObjectCertificate(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) diff --git a/core/ox/kind_vol.go b/core/ox/kind_vol.go index 72d3f0f61..85d8c5951 100644 --- a/core/ox/kind_vol.go +++ b/core/ox/kind_vol.go @@ -5,7 +5,7 @@ import "github.com/opensvc/om3/v3/core/commoncmd" func init() { kind := "vol" - cmdObject := newCmdVol() + cmdObject := commoncmd.NewCmdVol() cmdObjectCollector := commoncmd.NewCmdObjectCollector(kind) cmdObjectCollectorTag := newCmdObjectCollectorTag(kind) cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) diff --git a/core/oxcmd/options.go b/core/oxcmd/options.go index 2ed9e15ac..6cce822b0 100644 --- a/core/oxcmd/options.go +++ b/core/oxcmd/options.go @@ -1,11 +1,10 @@ package oxcmd +import "github.com/opensvc/om3/v3/core/commoncmd" + type ( // OptsGlobal contains options accepted by all actions OptsGlobal struct { - Color string - Output string - ObjectSelector string - IgnoreNotFound bool + commoncmd.OptsGlobal } ) From d67f74c5e494e90102f0dc30a429cf97f757eeb8 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 8 Jul 2026 22:11:29 +0200 Subject: [PATCH 31/32] Factorize more core/o[mx] code into commoncmd - add nscfg Continue the work of commit d396c673f by adding the missing NewCmdNscfg() function to commoncmd/factory_kind.go and updating both om and ox kind_nscfg.go files to use it. --- core/commoncmd/factory_kind.go | 8 ++++++++ core/om/kind_nscfg.go | 7 +------ core/ox/kind_nscfg.go | 7 +------ 3 files changed, 10 insertions(+), 12 deletions(-) diff --git a/core/commoncmd/factory_kind.go b/core/commoncmd/factory_kind.go index c0e4ba70b..3dc3bf5f2 100644 --- a/core/commoncmd/factory_kind.go +++ b/core/commoncmd/factory_kind.go @@ -111,3 +111,11 @@ to satisfy a demand from a volume resource in a service. Volumes and their subdirectories can be mounted inside containers.`, } } + +// NewCmdNscfg creates the "nscfg" command +func NewCmdNscfg() *cobra.Command { + return &cobra.Command{ + Use: "nscfg", + Short: "manage namespace configurations", + } +} diff --git a/core/om/kind_nscfg.go b/core/om/kind_nscfg.go index e1126c805..c9b0365a0 100644 --- a/core/om/kind_nscfg.go +++ b/core/om/kind_nscfg.go @@ -1,8 +1,6 @@ package om import ( - "github.com/spf13/cobra" - "github.com/opensvc/om3/v3/core/commoncmd" "github.com/opensvc/om3/v3/core/omcmd" ) @@ -10,10 +8,7 @@ import ( func init() { kind := "nscfg" - cmdObject := &cobra.Command{ - Use: "nscfg", - Short: "manage namespace configurations", - } + cmdObject := commoncmd.NewCmdNscfg() cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) diff --git a/core/ox/kind_nscfg.go b/core/ox/kind_nscfg.go index 18cc718d7..aa706011a 100644 --- a/core/ox/kind_nscfg.go +++ b/core/ox/kind_nscfg.go @@ -1,8 +1,6 @@ package ox import ( - "github.com/spf13/cobra" - "github.com/opensvc/om3/v3/core/commoncmd" "github.com/opensvc/om3/v3/core/omcmd" ) @@ -10,10 +8,7 @@ import ( func init() { kind := "nscfg" - cmdObject := &cobra.Command{ - Use: "nscfg", - Short: "manage namespace configurations", - } + cmdObject := commoncmd.NewCmdNscfg() cmdObjectConfig := commoncmd.NewCmdObjectConfig(kind) cmdObjectEdit := newCmdObjectEdit(kind) cmdObjectInstance := commoncmd.NewCmdObjectInstance(kind) From 4a87690b1e46465a9e2c075de19a1d8832ddefc5 Mon Sep 17 00:00:00 2001 From: Christophe Varoqui Date: Wed, 8 Jul 2026 22:51:59 +0200 Subject: [PATCH 32/32] Factorize more core/o[mx] code into commoncmd Continue the work of previous commits by adding more command factory functions: - NewCmdNetwork, NewCmdNetworkIP - NewCmdPool, NewCmdPoolVolume - NewCmdNodeCapabilities, NewCmdNodeCompliance - NewCmdNodeCollector, NewCmdNodeCollectorTag - NewCmdNodeSCSI - NewCmdNodeRelay - NewCmdNodeSSH These are top-level and subsystem commands that have identical definitions in both om and ox packages. --- core/commoncmd/factory_kind.go | 100 +++++++++++++++++++++++++++++++++ core/om/network.go | 14 +---- core/om/node.go | 32 ++--------- core/om/pool.go | 14 +---- core/ox/network.go | 14 +---- core/ox/node.go | 32 ++--------- core/ox/pool.go | 14 +---- 7 files changed, 122 insertions(+), 98 deletions(-) diff --git a/core/commoncmd/factory_kind.go b/core/commoncmd/factory_kind.go index 3dc3bf5f2..6ad0b5553 100644 --- a/core/commoncmd/factory_kind.go +++ b/core/commoncmd/factory_kind.go @@ -119,3 +119,103 @@ func NewCmdNscfg() *cobra.Command { Short: "manage namespace configurations", } } + +// NewCmdNetwork creates the "network" command +func NewCmdNetwork() *cobra.Command { + return &cobra.Command{ + Use: "network", + Short: "manage backend networks", + Aliases: []string{"net"}, + Long: "A backend network provides ip addresses to svc objects via ip.cni resources. These addresses are automatically allocated, accessible from all cluster nodes, and resolved by the cluster dns.", + } +} + +// NewCmdNetworkIP creates the "ip" subcommand for network +func NewCmdNetworkIP() *cobra.Command { + return &cobra.Command{ + Use: "ip", + Short: "manage ip on backend networks", + } +} + +// NewCmdPool creates the "pool" command +func NewCmdPool() *cobra.Command { + return &cobra.Command{ + Use: "pool", + Short: "manage storage pools", + Long: " A pool is a vol provider. Pools abstract the hardware and software specificities of the cluster infrastructure.", + } +} + +// NewCmdPoolVolume creates the "volume" subcommand for pool +func NewCmdPoolVolume() *cobra.Command { + return &cobra.Command{ + Use: "volume", + Short: "manage storage pool volumes", + Aliases: []string{"vol"}, + } +} + +// NewCmdNodeCapabilities creates the "capabilities" subcommand for node +func NewCmdNodeCapabilities() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "capabilities", + Short: "scan and list what the node is capable of", + Aliases: []string{"capa", "caps", "cap"}, + } +} + +// NewCmdNodeCollector creates the "collector" subcommand for node +func NewCmdNodeCollector() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "collector", + Short: "node collector data management commands", + } +} + +// NewCmdNodeCollectorTag creates the "tag" subcommand for node collector +func NewCmdNodeCollectorTag() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "tag", + Short: "collector tags management commands", + } +} + +// NewCmdNodeCompliance creates the "compliance" subcommand for node +func NewCmdNodeCompliance() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "compliance", + Short: "node configuration manager commands", + } +} + +// NewCmdNodeSCSI creates the "scsi" subcommand for node +func NewCmdNodeSCSI() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "scsi", + Short: "scsi commands", + } +} + +// NewCmdNodeRelay creates the "relay" subcommand for node +func NewCmdNodeRelay() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "relay", + Short: "relay commands", + } +} + +// NewCmdNodeSSH creates the "ssh" subcommand for node +func NewCmdNodeSSH() *cobra.Command { + return &cobra.Command{ + GroupID: GroupIDSubsystems, + Use: "ssh", + Short: "ssh commands", + } +} diff --git a/core/om/network.go b/core/om/network.go index ed34b481e..4e0b2161a 100644 --- a/core/om/network.go +++ b/core/om/network.go @@ -1,20 +1,12 @@ package om import ( - "github.com/spf13/cobra" + "github.com/opensvc/om3/v3/core/commoncmd" ) var ( - cmdNetwork = &cobra.Command{ - Use: "network", - Short: "manage backend networks", - Aliases: []string{"net"}, - Long: `A backend network provides ip addresses to svc objects via ip.cni resources. These addresses are automatically allocated, accessible from all cluster nodes, and resolved by the cluster dns.`, - } - cmdNetworkIP = &cobra.Command{ - Use: "ip", - Short: "manage ip on backend networks", - } + cmdNetwork = commoncmd.NewCmdNetwork() + cmdNetworkIP = commoncmd.NewCmdNetworkIP() ) func init() { diff --git a/core/om/node.go b/core/om/node.go index b5e56c088..f7a11d024 100644 --- a/core/om/node.go +++ b/core/om/node.go @@ -10,12 +10,7 @@ import ( var ( cmdNode = commoncmd.NewCmdNode() - cmdNodeCapabilities = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "capabilities", - Short: "scan and list what the node is capable of", - Aliases: []string{"capa", "caps", "cap"}, - } + cmdNodeCapabilities = commoncmd.NewCmdNodeCapabilities() cmdNodeCollector = &cobra.Command{ GroupID: commoncmd.GroupIDSubsystems, Use: "collector", @@ -27,28 +22,15 @@ var ( Use: "tag", Short: "collector tags management commands", } - cmdNodeCompliance = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "compliance", - Short: "node configuration manager commands", - Aliases: []string{"comp"}, - } + cmdNodeCompliance = commoncmd.NewCmdNodeCompliance() cmdNodeConfig = &cobra.Command{ GroupID: commoncmd.GroupIDSubsystems, Use: "config", Short: "configuration commands", Aliases: []string{"conf", "c", "cf", "cfg"}, } - cmdNodeSCSI = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "scsi", - Short: "scsi commands", - } - cmdNodeRelay = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "relay", - Short: "relay commands", - } + cmdNodeSCSI = commoncmd.NewCmdNodeSCSI() + cmdNodeRelay = commoncmd.NewCmdNodeRelay() cmdNodeScan = &cobra.Command{ Use: "scan", Hidden: true, @@ -58,11 +40,7 @@ var ( Use: "schedule", Short: "scheduler commands", } - cmdNodeSSH = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "ssh", - Short: "ssh commands", - } + cmdNodeSSH = commoncmd.NewCmdNodeSSH() // Backward compat diff --git a/core/om/pool.go b/core/om/pool.go index f799142af..27f19e5a1 100644 --- a/core/om/pool.go +++ b/core/om/pool.go @@ -1,20 +1,12 @@ package om import ( - "github.com/spf13/cobra" + "github.com/opensvc/om3/v3/core/commoncmd" ) var ( - cmdPool = &cobra.Command{ - Use: "pool", - Short: "manage storage pools", - Long: ` A pool is a vol provider. Pools abstract the hardware and software specificities of the cluster infrastructure.`, - } - cmdPoolVolume = &cobra.Command{ - Use: "volume", - Short: "manage storage pool volumes", - Aliases: []string{"vol"}, - } + cmdPool = commoncmd.NewCmdPool() + cmdPoolVolume = commoncmd.NewCmdPoolVolume() ) func init() { diff --git a/core/ox/network.go b/core/ox/network.go index 1bc9daea1..88ad62c4d 100644 --- a/core/ox/network.go +++ b/core/ox/network.go @@ -1,20 +1,12 @@ package ox import ( - "github.com/spf13/cobra" + "github.com/opensvc/om3/v3/core/commoncmd" ) var ( - cmdNetwork = &cobra.Command{ - Use: "network", - Short: "manage backend networks", - Aliases: []string{"net"}, - Long: `A backend network provides ip addresses to svc objects via ip.cni resources. These addresses are automatically allocated, accessible from all cluster nodes, and resolved by the cluster dns.`, - } - cmdNetworkIP = &cobra.Command{ - Use: "ip", - Short: "manage ip on backend networks", - } + cmdNetwork = commoncmd.NewCmdNetwork() + cmdNetworkIP = commoncmd.NewCmdNetworkIP() ) func init() { diff --git a/core/ox/node.go b/core/ox/node.go index 5d701c917..2508f0cc0 100644 --- a/core/ox/node.go +++ b/core/ox/node.go @@ -8,50 +8,28 @@ import ( var ( cmdNode = commoncmd.NewCmdNode() - cmdNodeCapabilities = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "capabilities", - Short: "scan and list what the node is capable of", - Aliases: []string{"capa", "caps", "cap"}, - } + cmdNodeCapabilities = commoncmd.NewCmdNodeCapabilities() cmdNodeCollector = &cobra.Command{ GroupID: commoncmd.GroupIDSubsystems, Use: "collector", Short: "node collector data management commands", Aliases: []string{"coll"}, } - cmdNodeSCSI = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "scsi", - Short: "scsi commands", - } + cmdNodeSCSI = commoncmd.NewCmdNodeSCSI() cmdNodeCollectorTag = &cobra.Command{ GroupID: commoncmd.GroupIDSubsystems, Use: "tag", Short: "collector tags commands", } - cmdNodeCompliance = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "compliance", - Short: "node configuration manager commands", - Aliases: []string{"comp"}, - } - cmdNodeRelay = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "relay", - Short: "relay commands", - } + cmdNodeCompliance = commoncmd.NewCmdNodeCompliance() + cmdNodeRelay = commoncmd.NewCmdNodeRelay() cmdNodeSchedule = &cobra.Command{ GroupID: commoncmd.GroupIDSubsystems, Use: "schedule", Short: "scheduler commands", Aliases: []string{"sched"}, } - cmdNodeSSH = &cobra.Command{ - GroupID: commoncmd.GroupIDSubsystems, - Use: "ssh", - Short: "ssh commands", - } + cmdNodeSSH = commoncmd.NewCmdNodeSSH() cmdNodeConfig = &cobra.Command{ GroupID: commoncmd.GroupIDSubsystems, Use: "config", diff --git a/core/ox/pool.go b/core/ox/pool.go index 82ce12fc7..18baad7fe 100644 --- a/core/ox/pool.go +++ b/core/ox/pool.go @@ -1,20 +1,12 @@ package ox import ( - "github.com/spf13/cobra" + "github.com/opensvc/om3/v3/core/commoncmd" ) var ( - cmdPool = &cobra.Command{ - Use: "pool", - Short: "manage storage pools", - Long: ` A pool is a vol provider. Pools abstract the hardware and software specificities of the cluster infrastructure.`, - } - cmdPoolVolume = &cobra.Command{ - Use: "volume", - Short: "manage storage pool volumes", - Aliases: []string{"vol"}, - } + cmdPool = commoncmd.NewCmdPool() + cmdPoolVolume = commoncmd.NewCmdPoolVolume() ) func init() {