pvectl 0.2.0

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing templates (both VM and container).
+        #
+        # Queries both VM and Container repositories, filters by template? == true,
+        # and merges into a single list. Supports --type flag for filtering by
+        # resource type (vm/ct/qemu/lxc).
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("templates")
+        #   templates = handler.list(type_filter: "vm")
+        #
+        # @see Pvectl::Repositories::Vm VM repository
+        # @see Pvectl::Repositories::Container Container repository
+        # @see Pvectl::Presenters::Template Template presenter
+        #
+        class Templates
+          include ResourceHandler
+
+          # Type filter mapping — normalizes user input to API type values.
+          TYPE_MAP = {
+            "vm" => "qemu",
+            "qemu" => "qemu",
+            "ct" => "lxc",
+            "container" => "lxc",
+            "lxc" => "lxc"
+          }.freeze
+
+          # Sort field mappings for template listing.
+          SORT_FIELDS = {
+            "name" => ->(t) { t.name || "" },
+            "node" => ->(t) { t.node || "" },
+            "type" => ->(t) { t.type || "" },
+            "disk" => ->(t) { -(t.maxdisk || 0) }
+          }.freeze
+
+          # Creates handler with optional repositories for dependency injection.
+          #
+          # @param vm_repository [Repositories::Vm, nil] VM repository
+          # @param container_repository [Repositories::Container, nil] Container repository
+          def initialize(vm_repository: nil, container_repository: nil)
+            @vm_repository = vm_repository
+            @container_repository = container_repository
+          end
+
+          # Lists templates with optional filtering.
+          #
+          # @param node [String, nil] filter by node name
+          # @param type_filter [String, nil] filter by type (vm, ct, qemu, lxc)
+          # @param sort [String, nil] sort field
+          # @param name [String, nil] unused, interface compatibility
+          # @raise [ArgumentError] if type_filter is not a recognized type
+          # @return [Array<Models::Vm, Models::Container>] template models
+          def list(node: nil, name: nil, type_filter: nil, sort: nil, **_options)
+            validate_type_filter!(type_filter)
+
+            templates = []
+
+            unless skip_vms?(type_filter)
+              vms = vm_repository.list(node: node)
+              templates.concat(vms.select(&:template?))
+            end
+
+            unless skip_containers?(type_filter)
+              containers = container_repository.list(node: node)
+              templates.concat(containers.select(&:template?))
+            end
+
+            templates = apply_sort(templates, sort) if sort
+            templates
+          end
+
+          # Returns presenter for templates.
+          #
+          # @return [Presenters::Template] template presenter
+          def presenter
+            Pvectl::Presenters::Template.new
+          end
+
+          private
+
+          # Validates type_filter value against known types.
+          #
+          # @param type_filter [String, nil] type filter value
+          # @raise [ArgumentError] if type_filter is not a recognized type
+          # @return [void]
+          def validate_type_filter!(type_filter)
+            return if type_filter.nil?
+            return if TYPE_MAP.key?(type_filter)
+
+            valid_types = TYPE_MAP.keys.join(", ")
+            raise ArgumentError, "Unknown type: #{type_filter}. Valid types: #{valid_types}"
+          end
+
+          # Returns VM repository, creating it if necessary.
+          #
+          # @return [Repositories::Vm]
+          def vm_repository
+            @vm_repository ||= build_vm_repository
+          end
+
+          # Returns Container repository, creating it if necessary.
+          #
+          # @return [Repositories::Container]
+          def container_repository
+            @container_repository ||= build_container_repository
+          end
+
+          # Builds VM repository with connection from config.
+          #
+          # @return [Repositories::Vm]
+          def build_vm_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Vm.new(connection)
+          end
+
+          # Builds Container repository with connection from config.
+          #
+          # @return [Repositories::Container]
+          def build_container_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Container.new(connection)
+          end
+
+          # Checks if VMs should be skipped based on type filter.
+          #
+          # @param type_filter [String, nil] type filter value
+          # @return [Boolean]
+          def skip_vms?(type_filter)
+            return false if type_filter.nil?
+
+            TYPE_MAP[type_filter] == "lxc"
+          end
+
+          # Checks if containers should be skipped based on type filter.
+          #
+          # @param type_filter [String, nil] type filter value
+          # @return [Boolean]
+          def skip_containers?(type_filter)
+            return false if type_filter.nil?
+
+            TYPE_MAP[type_filter] == "qemu"
+          end
+
+          # Applies sorting to templates collection.
+          #
+          # @param templates [Array] templates to sort
+          # @param sort_field [String] field to sort by
+          # @return [Array] sorted templates
+          def apply_sort(templates, sort_field)
+            sort_proc = SORT_FIELDS[sort_field.to_s]
+            return templates unless sort_proc
+
+            templates.sort_by(&sort_proc)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "templates",
+  Pvectl::Commands::Get::Handlers::Templates,
+  aliases: ["template"]
+)

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing node time and timezone settings.
+        #
+        # Implements ResourceHandler interface for the "time" resource type.
+        # When `--node` is supplied, returns the time config for that single node.
+        # Otherwise, iterates over all online nodes and aggregates their time configs.
+        # Unreachable nodes (those that raise during fetch) are silently skipped so
+        # one bad node does not abort the whole listing.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("time")
+        #   configs = handler.list(node: "pve1")
+        #
+        # @see Pvectl::Commands::Get::ResourceHandler Handler interface
+        # @see Pvectl::Repositories::TimeConfig Time repository
+        # @see Pvectl::Presenters::TimeConfig Time presenter
+        #
+        class Time
+          include ResourceHandler
+
+          # Creates handler with optional repositories for dependency injection.
+          #
+          # @param repository [Repositories::TimeConfig, nil] time repository
+          # @param node_repository [Repositories::Node, nil] node repository
+          def initialize(repository: nil, node_repository: nil)
+            @repository = repository
+            @node_repository = node_repository
+          end
+
+          # Lists time/timezone configs.
+          #
+          # @param node [String, nil] when given, only that node is queried;
+          #   otherwise iterates all online nodes
+          # @param name [String, nil] unused, for interface compatibility
+          # @param args [Array<String>] unused, for interface compatibility
+          # @param storage [String, nil] unused, for interface compatibility
+          # @return [Array<Models::TimeConfig>] one entry per node queried
+          # @raise [Pvectl::ResourceNotFoundError] if a specific node was requested but does not exist
+          def list(node: nil, name: nil, args: [], storage: nil, **_options)
+            return [fetch_for(node)] if node
+
+            online_node_names.filter_map do |node_name|
+              begin
+                repository.fetch(node_name)
+              rescue StandardError
+                # Skip unreachable nodes - one bad node should not abort the listing.
+                nil
+              end
+            end
+          end
+
+          # Returns presenter for time configs.
+          #
+          # @return [Presenters::TimeConfig]
+          def presenter
+            Pvectl::Presenters::TimeConfig.new
+          end
+
+          private
+
+          # Fetches the time config for a specific node, raising ResourceNotFoundError
+          # if the node itself does not exist in the cluster.
+          #
+          # @param node_name [String] node name
+          # @return [Models::TimeConfig]
+          # @raise [Pvectl::ResourceNotFoundError] if the node does not exist
+          def fetch_for(node_name)
+            unless node_repository.get(node_name)
+              raise Pvectl::ResourceNotFoundError, "Node not found: #{node_name}"
+            end
+
+            repository.fetch(node_name)
+          end
+
+          # Names of online nodes (offline nodes are skipped because querying
+          # them is guaranteed to fail).
+          #
+          # @return [Array<String>] node names
+          def online_node_names
+            node_repository.list.select { |n| n.status == "online" }.map(&:name)
+          end
+
+          # @return [Repositories::TimeConfig] time repository, lazily built
+          def repository
+            @repository ||= Pvectl::Repositories::TimeConfig.new(connection)
+          end
+
+          # @return [Repositories::Node] node repository, lazily built
+          def node_repository
+            @node_repository ||= Pvectl::Repositories::Node.new(connection)
+          end
+
+          # Builds API connection from 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
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "time",
+  Pvectl::Commands::Get::Handlers::Time
+)

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

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

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing and describing virtual disk volumes.
+        #
+        # Implements ResourceHandler interface for the "volumes" resource type.
+        # Supports two listing modes:
+        # - Config mode: list volumes from VM/CT config by resource type and IDs
+        # - Storage mode: list volumes from a specific storage
+        #
+        # Uses Repositories::Volume for data access, Presenters::Volume for
+        # formatting, and Selectors::Volume for client-side filtering.
+        #
+        # @example List VM volumes via ResourceRegistry
+        #   handler = ResourceRegistry.for("volumes")
+        #   volumes = handler.list(args: ["vm", "100"], node: "pve1")
+        #
+        # @example List storage volumes
+        #   handler = ResourceRegistry.for("volumes")
+        #   volumes = handler.list(storage: "local-lvm")
+        #
+        # @example Describe a specific volume
+        #   handler = ResourceRegistry.for("volumes")
+        #   volume = handler.describe(name: "vm", args: ["100", "scsi0"])
+        #
+        # @see Pvectl::Commands::Get::ResourceHandler Handler interface
+        # @see Pvectl::Repositories::Volume Volume repository
+        # @see Pvectl::Presenters::Volume Volume presenter
+        #
+        class Volume
+          include ResourceHandler
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Volume, nil] repository (default: create new)
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Lists virtual disk volumes with two modes of operation.
+          #
+          # Config mode: requires resource type and at least one ID in args.
+          #   args = ["vm", "100", "101"] lists volumes from VMs 100 and 101.
+          #
+          # Storage mode: requires storage parameter.
+          #   storage = "local-lvm" lists all volumes on that storage.
+          #
+          # @param args [Array<String>] resource type and IDs (config mode)
+          # @param storage [String, nil] storage name (storage mode)
+          # @param node [String, nil] filter by node name
+          # @param _options [Hash] unused, for interface compatibility
+          # @return [Array<Models::Volume>] collection of Volume models
+          def list(args: [], storage: nil, node: nil, **_options)
+            if storage
+              repository.list_from_storage(storage: storage, node: node)
+            elsif args.length >= 2
+              resource_type = args[0]
+              ids = args[1..].map(&:to_i)
+              repository.list_from_config(resource_type: resource_type, ids: ids, node: node)
+            else
+              $stderr.puts "Usage: pvectl get volume <vm|ct> <ID...> [--node NODE]"
+              $stderr.puts "       pvectl get volume --storage <STORAGE> [--node NODE]"
+              []
+            end
+          end
+
+          # Describes a single virtual disk volume.
+          #
+          # Locates a specific disk by resource type, ID, and disk name.
+          #
+          # @param name [String] resource type ("vm" or "ct")
+          # @param args [Array<String>] [id, disk_name] pair
+          # @param node [String, nil] optional node filter
+          # @param _options [Hash] unused, for interface compatibility
+          # @return [Models::Volume] found Volume model
+          # @raise [Pvectl::ResourceNotFoundError] when volume not found
+          def describe(name:, args: [], node: nil, **_options)
+            resource_type = name
+            id = args[0]&.to_i
+            disk_name = args[1]
+
+            volume = repository.find(resource_type: resource_type, id: id, disk_name: disk_name, node: node)
+            raise Pvectl::ResourceNotFoundError, "Volume '#{disk_name}' not found on #{resource_type} #{id}" unless volume
+
+            volume
+          end
+
+          # Returns presenter for virtual disk volumes.
+          #
+          # @return [Presenters::Volume] Volume presenter instance
+          def presenter
+            Pvectl::Presenters::Volume.new
+          end
+
+          # Returns selector class for client-side filtering.
+          #
+          # @return [Class] Selectors::Volume class
+          def selector_class
+            Pvectl::Selectors::Volume
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Volume] Volume repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Volume] configured Volume repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Volume.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "volumes",
+  Pvectl::Commands::Get::Handlers::Volume,
+  aliases: ["volume", "vol"]
+)

data/lib/pvectl/commands/get/resource_handler.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      # Interface module for resource handlers.
+      #
+      # Each resource type (nodes, vms, containers, storage) implements
+      # this interface to provide listing capabilities.
+      #
+      # Minimal interface with two methods:
+      # - #list - fetches and returns model objects
+      # - #presenter - returns presenter for formatting
+      #
+      # @abstract Include in handler class and implement required methods.
+      #
+      # @example Implementing a handler
+      #   class NodesHandler
+      #     include ResourceHandler
+      #
+      #     def list(node: nil, name: nil)
+      #       # Fetch and return array of Node models
+      #       repository.list.select { |n| name.nil? || n.name == name }
+      #     end
+      #
+      #     def presenter
+      #       Presenters::Node.new
+      #     end
+      #   end
+      #
+      module ResourceHandler
+        # Lists resources, optionally filtered by node and name.
+        #
+        # @param node [String, nil] filter by node name (for VMs/containers)
+        # @param name [String, nil] filter by resource name
+        # @param _options [Hash] additional options passed through from CLI (e.g., limit, since, type_filter)
+        # @return [Array<Object>] collection of model objects
+        # @raise [NotImplementedError] if not implemented by including class
+        def list(node: nil, name: nil, **_options)
+          raise NotImplementedError, "#{self.class}#list must be implemented"
+        end
+
+        # Returns the presenter for this resource type.
+        #
+        # @return [Presenters::Base] presenter instance
+        # @raise [NotImplementedError] if not implemented by including class
+        def presenter
+          raise NotImplementedError, "#{self.class}#presenter must be implemented"
+        end
+
+        # Returns the selector class for client-side filtering.
+        #
+        # Handlers that support selector-based filtering (e.g., -l status=running)
+        # should override this to return their selector class.
+        #
+        # @return [Class, nil] selector class (e.g., Selectors::Vm) or nil if not supported
+        def selector_class
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/get/resource_registry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      # Registry for Get command resource handlers.
+      #
+      # Inherits all registration and lookup logic from Commands::ResourceRegistry.
+      # Each handler registers itself at load time.
+      #
+      # @example Looking up a handler
+      #   handler = ResourceRegistry.for("nodes")
+      #   handler.list(node: "pve1") if handler
+      #
+      class ResourceRegistry < Commands::ResourceRegistry; end
+    end
+  end
+end