pvectl 0.2.0

data/lib/pvectl/commands/get/handlers/backups.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing backups.
+        #
+        # Unlike Snapshots handler, Backups allows listing all backups
+        # or filtering by optional VMID.
+        #
+        # @example Usage
+        #   handler.list(node: nil, name: nil, args: [])        # all backups
+        #   handler.list(node: nil, name: nil, args: ["100"])   # backups for VM 100
+        #
+        class Backups
+          include ResourceHandler
+
+          def initialize(service: nil)
+            @service = service
+          end
+
+          # Lists backups with optional VMID filter.
+          #
+          # @param node [String, nil] ignored (backups can span nodes)
+          # @param name [String, nil] ignored
+          # @param args [Array<String>] optional VMID filter (first arg only)
+          # @param storage [String, nil] filter by storage
+          # @return [Array<Models::Backup>] collection of backup models
+          def list(node: nil, name: nil, args: [], storage: nil, **_options)
+            vmid = args.first&.to_i
+            vmid = nil if vmid&.zero?
+
+            service.list(vmid: vmid, storage: storage)
+          end
+
+          # Returns presenter for backups.
+          #
+          # @return [Presenters::Backup] backup presenter instance
+          def presenter
+            Pvectl::Presenters::Backup.new
+          end
+
+          private
+
+          def service
+            @service ||= build_service
+          end
+
+          def build_service
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+
+            backup_repo = Pvectl::Repositories::Backup.new(connection)
+            resolver = Pvectl::Utils::ResourceResolver.new(connection)
+            task_repo = Pvectl::Repositories::Task.new(connection)
+
+            Pvectl::Services::Backup.new(
+              backup_repo: backup_repo,
+              resource_resolver: resolver,
+              task_repo: task_repo
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "backups",
+  Pvectl::Commands::Get::Handlers::Backups,
+  aliases: ["backup"]
+)

data/lib/pvectl/commands/get/handlers/capabilities.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for `pvectl get node-capabilities`.
+        #
+        # Surfaces what features a node supports — primarily the available
+        # QEMU CPU models and machine types. When `--node` is provided the
+        # query is scoped to that node; otherwise the handler iterates all
+        # online nodes and aggregates the results, silently skipping
+        # unreachable nodes (matches the pattern used by the time handler).
+        #
+        # @see Pvectl::Repositories::Capabilities
+        # @see Pvectl::Presenters::Capability
+        #
+        class Capabilities
+          include ResourceHandler
+
+          # @param repository [Repositories::Capabilities, nil] capability repo (DI)
+          # @param node_repository [Repositories::Node, nil] node repo (DI)
+          def initialize(repository: nil, node_repository: nil)
+            @repository = repository
+            @node_repository = node_repository
+          end
+
+          # Lists capabilities, optionally scoped to a node.
+          #
+          # @param node [String, nil] when provided, only that node is queried
+          # @param name [String, nil] unused, interface compatibility
+          # @param args [Array<String>] unused, interface compatibility
+          # @param storage [String, nil] unused, interface compatibility
+          # @return [Array<Models::Capability>]
+          # @raise [Pvectl::ResourceNotFoundError] if a specific node is requested but missing
+          def list(node: nil, name: nil, args: [], storage: nil, **_options)
+            return fetch_for(node) if node
+
+            online_node_names.flat_map do |node_name|
+              repository.list(node: node_name)
+            rescue StandardError
+              []
+            end
+          end
+
+          # Returns the capability presenter.
+          #
+          # @return [Presenters::Capability]
+          def presenter
+            Pvectl::Presenters::Capability.new
+          end
+
+          private
+
+          # Fetches capabilities for a specific node, raising when the node
+          # itself does not exist in the cluster.
+          #
+          # @param node_name [String]
+          # @return [Array<Models::Capability>]
+          # @raise [Pvectl::ResourceNotFoundError]
+          def fetch_for(node_name)
+            unless node_repository.get(node_name)
+              raise Pvectl::ResourceNotFoundError, "Node not found: #{node_name}"
+            end
+
+            repository.list(node: node_name)
+          end
+
+          # Names of online nodes.
+          #
+          # @return [Array<String>]
+          def online_node_names
+            node_repository.list.select { |n| n.status == "online" }.map(&:name)
+          end
+
+          # @return [Repositories::Capabilities]
+          def repository
+            @repository ||= Pvectl::Repositories::Capabilities.new(connection)
+          end
+
+          # @return [Repositories::Node]
+          def node_repository
+            @node_repository ||= Pvectl::Repositories::Node.new(connection)
+          end
+
+          # Builds API connection from the current config.
+          #
+          # @return [Pvectl::Connection]
+          def connection
+            @connection ||= begin
+              config_service = Pvectl::Config::Service.new
+              config_service.load
+              Pvectl::Connection.new(config_service.current_config)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry under the spec name plus aliases.
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "node-capabilities",
+  Pvectl::Commands::Get::Handlers::Capabilities,
+  aliases: ["capabilities", "caps", "node-capability"]
+)

data/lib/pvectl/commands/get/handlers/containers.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing LXC containers.
+        #
+        # Implements ResourceHandler interface for the "containers" resource type.
+        # Uses Repositories::Container for data access and Presenters::Container for formatting.
+        #
+        # Registered with ResourceRegistry on file load for "containers", "container", "ct", and "cts".
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("containers")
+        #   containers = handler.list(node: "pve1")
+        #   presenter = handler.presenter
+        #
+        # @see Pvectl::Commands::Get::ResourceHandler Handler interface
+        # @see Pvectl::Repositories::Container Container repository
+        # @see Pvectl::Presenters::Container Container presenter
+        #
+        class Containers
+          include ResourceHandler
+
+          # CTID validation pattern (100-999999999)
+          CTID_PATTERN = /\A[1-9]\d{2,8}\z/
+
+          # Sort field mappings.
+          # Negative values for descending sort (higher values first).
+          SORT_FIELDS = {
+            "name" => ->(c) { c.name || "" },
+            "node" => ->(c) { c.node || "" },
+            "cpu" => ->(c) { -(c.cpu || 0) },
+            "memory" => ->(c) { -(c.mem || 0) },
+            "disk" => ->(c) { -(c.disk || 0) },
+            "netin" => ->(c) { -(c.netin || 0) },
+            "netout" => ->(c) { -(c.netout || 0) }
+          }.freeze
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Container, nil] repository (default: create new)
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Returns selector class for container filtering.
+          #
+          # @return [Class] Selectors::Container
+          def selector_class
+            Pvectl::Selectors::Container
+          end
+
+          # Lists containers with optional filtering and sorting.
+          #
+          # @param node [String, nil] filter by node name
+          # @param name [String, nil] filter by container name
+          # @param args [Array<String>] unused, for interface compatibility
+          # @param storage [String, nil] unused, for interface compatibility
+          # @param sort [String, nil] sort field (name, node, cpu, memory, disk, netin, netout)
+          # @return [Array<Models::Container>] collection of Container models
+          def list(node: nil, name: nil, args: [], storage: nil, sort: nil, **_options)
+            containers = repository.list(node: node)
+            containers = containers.select { |c| c.name == name } if name
+            containers = apply_sort(containers, sort) if sort
+            containers
+          end
+
+          # Returns presenter for containers.
+          #
+          # @return [Presenters::Container] Container presenter instance
+          def presenter
+            Pvectl::Presenters::Container.new
+          end
+
+          # Describes a single container with comprehensive details.
+          #
+          # @param name [String] CTID as string (consistent with handler interface)
+          # @param node [String, nil] unused, for API consistency
+          # @return [Models::Container] Container model with full details
+          # @raise [ArgumentError] if CTID format is invalid
+          # @raise [Pvectl::ResourceNotFoundError] if container not found
+          def describe(name:, node: nil, args: [], vmid: nil)
+            raise ArgumentError, "Invalid CTID: must be positive integer (100-999999999)" unless valid_ctid?(name)
+
+            ctid = name.to_i
+            container = repository.describe(ctid)
+            raise Pvectl::ResourceNotFoundError, "Container not found: #{ctid}" if container.nil?
+
+            container
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Container] Container repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Container] configured Container repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Container.new(connection)
+          end
+
+          # Applies sorting to containers collection.
+          #
+          # @param containers [Array<Models::Container>] containers to sort
+          # @param sort_field [String] field to sort by
+          # @return [Array<Models::Container>] sorted containers
+          def apply_sort(containers, sort_field)
+            sort_proc = SORT_FIELDS[sort_field.to_s]
+            return containers unless sort_proc
+
+            containers.sort_by(&sort_proc)
+          end
+
+          # Validates CTID format.
+          #
+          # CTID must be a positive integer between 100 and 999999999.
+          # The minimum CTID in Proxmox is 100 (unlike VMID which can be 1).
+          #
+          # @param ctid [String, nil] CTID to validate
+          # @return [Boolean] true if valid
+          def valid_ctid?(ctid)
+            return false if ctid.nil? || ctid.to_s.empty?
+
+            ctid.to_s.match?(CTID_PATTERN)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "containers",
+  Pvectl::Commands::Get::Handlers::Containers,
+  aliases: ["container", "ct", "cts"]
+)

data/lib/pvectl/commands/get/handlers/disks.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing physical disks on Proxmox nodes.
+        #
+        # Implements ResourceHandler interface for the "disks" resource type.
+        # Uses Repositories::Disk for data access and Presenters::Disk for formatting.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("disks")
+        #   disks = handler.list(node: "pve1")
+        #
+        # @see Pvectl::Commands::Get::ResourceHandler Handler interface
+        # @see Pvectl::Repositories::Disk Disk repository
+        # @see Pvectl::Presenters::Disk Disk presenter
+        #
+        class Disks
+          include ResourceHandler
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Disk, nil] repository (default: create new)
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Lists physical disks with optional filtering.
+          #
+          # @param node [String, nil] filter by node name
+          # @param name [String, nil] filter by device path (e.g., "/dev/sda")
+          # @param args [Array<String>] unused, for interface compatibility
+          # @param storage [String, nil] unused, for interface compatibility
+          # @return [Array<Models::PhysicalDisk>] collection of PhysicalDisk models
+          def list(node: nil, name: nil, args: [], storage: nil, **_options)
+            disks = repository.list(node: node)
+            disks = disks.select { |d| d.devpath == name } if name
+            disks
+          end
+
+          # Describes a single physical disk with SMART data.
+          #
+          # Locates the disk by devpath across all nodes (or a specific node),
+          # then fetches SMART data and merges it into the model.
+          #
+          # @param name [String] device path (e.g., "/dev/nvme0n1")
+          # @param node [String, nil] optional node filter
+          # @param args [Array<String>] unused, for interface compatibility
+          # @param vmid [String, nil] unused, for interface compatibility
+          # @return [Models::PhysicalDisk] enriched disk model
+          # @raise [Pvectl::ResourceNotFoundError] when disk not found
+          def describe(name:, node: nil, args: [], vmid: nil)
+            disks = repository.list(node: node)
+            disk = disks.find { |d| d.devpath == name }
+            raise Pvectl::ResourceNotFoundError, "Disk not found: #{name}" unless disk
+
+            smart_data = repository.smart(disk.node, name)
+            disk.merge_smart(smart_data)
+            disk
+          end
+
+          # Returns presenter for physical disks.
+          #
+          # @return [Presenters::Disk] Disk presenter instance
+          def presenter
+            Pvectl::Presenters::Disk.new
+          end
+
+          # Returns selector class for client-side filtering.
+          #
+          # @return [Class] Selectors::Disk class
+          def selector_class
+            Pvectl::Selectors::Disk
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Disk] Disk repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Disk] configured Disk repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Disk.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "disks",
+  Pvectl::Commands::Get::Handlers::Disks,
+  aliases: ["disk"]
+)

data/lib/pvectl/commands/get/handlers/dns.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for reading per-node DNS resolver settings.
+        #
+        # Implements ResourceHandler interface for the "dns" resource type.
+        # DNS is a singleton resource per node — there is no cluster-wide DNS
+        # configuration, so a node name is always required.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("dns")
+        #   dns = handler.list(node: "pve1") # => [DnsConfig]
+        #
+        # @see Pvectl::Repositories::Dns DNS repository
+        # @see Pvectl::Presenters::DnsConfig DNS presenter
+        #
+        class Dns
+          include ResourceHandler
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Dns, nil] DNS repository
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Returns the DNS configuration for the given node, wrapped in an array.
+          #
+          # @param node [String, nil] node name (REQUIRED — DNS is per-node)
+          # @param _options [Hash] unused, for interface compatibility
+          # @return [Array<Models::DnsConfig>] single-element array with the DNS config
+          # @raise [ArgumentError] when no node is provided
+          def list(node: nil, **_options)
+            raise ArgumentError, "DNS requires --node NODE to identify which node's settings to read" if node.nil? || node.to_s.empty?
+
+            [repository.fetch(node)]
+          end
+
+          # Returns presenter for DNS configuration.
+          #
+          # @return [Presenters::DnsConfig] DNS presenter instance
+          def presenter
+            Pvectl::Presenters::DnsConfig.new
+          end
+
+          # Describes the DNS configuration for a single node.
+          #
+          # Accepts either `name` (positional argument from describe command)
+          # or `node` (--node flag) as the node identifier.
+          #
+          # @param name [String, nil] node name (positional)
+          # @param node [String, nil] node name (--node flag, fallback)
+          # @param _opts [Hash] unused, for interface compatibility
+          # @return [Models::DnsConfig] DNS configuration model
+          # @raise [ArgumentError] when no node identifier given
+          def describe(name:, node: nil, **_opts)
+            node_name = name || node
+            raise ArgumentError, "Node name required: pvectl describe dns NODE or --node NODE" if node_name.nil? || node_name.to_s.empty?
+
+            repository.fetch(node_name)
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Dns] DNS repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Dns] configured DNS repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Dns.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "dns",
+  Pvectl::Commands::Get::Handlers::Dns
+)

data/lib/pvectl/commands/get/handlers/hosts.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for reading per-node /etc/hosts contents.
+        #
+        # Implements ResourceHandler interface for the "hosts" resource type.
+        # /etc/hosts is a singleton resource per node — there is no cluster-wide
+        # hosts file, so a node name is always required.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("hosts")
+        #   hosts = handler.list(node: "pve1") # => [HostsFile]
+        #
+        # @see Pvectl::Repositories::Hosts Hosts repository
+        # @see Pvectl::Presenters::HostsFile HostsFile presenter
+        #
+        class Hosts
+          include ResourceHandler
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Hosts, nil] Hosts repository
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Returns the /etc/hosts contents for the given node, wrapped in an array.
+          #
+          # @param node [String, nil] node name (REQUIRED — hosts is per-node)
+          # @param _options [Hash] unused, for interface compatibility
+          # @return [Array<Models::HostsFile>] single-element array with the hosts file
+          # @raise [ArgumentError] when no node is provided
+          def list(node: nil, **_options)
+            raise ArgumentError, "hosts requires --node NODE to identify which node's /etc/hosts to read" if node.nil? || node.to_s.empty?
+
+            [repository.fetch(node)]
+          end
+
+          # Returns presenter for /etc/hosts.
+          #
+          # @return [Presenters::HostsFile] HostsFile presenter instance
+          def presenter
+            Pvectl::Presenters::HostsFile.new
+          end
+
+          # Describes the /etc/hosts contents for a single node.
+          #
+          # Accepts either `name` (positional argument from describe command)
+          # or `node` (--node flag) as the node identifier.
+          #
+          # @param name [String, nil] node name (positional)
+          # @param node [String, nil] node name (--node flag, fallback)
+          # @param _opts [Hash] unused, for interface compatibility
+          # @return [Models::HostsFile] hosts file model
+          # @raise [ArgumentError] when no node identifier given
+          def describe(name:, node: nil, **_opts)
+            node_name = name || node
+            raise ArgumentError, "Node name required: pvectl describe hosts NODE or --node NODE" if node_name.nil? || node_name.to_s.empty?
+
+            repository.fetch(node_name)
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Hosts] hosts repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Hosts] configured hosts repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Hosts.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "hosts",
+  Pvectl::Commands::Get::Handlers::Hosts
+)