pvectl 0.2.0

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing Proxmox cluster nodes.
+        #
+        # Implements ResourceHandler interface for the "nodes" resource type.
+        # Uses Repositories::Node for data access and Presenters::Node for formatting.
+        #
+        # Supports filtering by status and sorting by various fields.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("nodes")
+        #   nodes = handler.list(filter: { status: "online" }, sort: "memory")
+        #
+        # @see Pvectl::Commands::Get::ResourceHandler Handler interface
+        # @see Pvectl::Repositories::Node Node repository
+        # @see Pvectl::Presenters::Node Node presenter
+        #
+        class Nodes
+          include ResourceHandler
+
+          # Sort field mappings.
+          # Negative values for descending sort (higher values first).
+          SORT_FIELDS = {
+            "name" => ->(n) { n.name },
+            "status" => ->(n) { n.status },
+            "cpu" => ->(n) { -(n.cpu || 0) },
+            "memory" => ->(n) { -(n.mem || 0) },
+            "disk" => ->(n) { -(n.disk || 0) },
+            "guests" => ->(n) { -n.guests_total },
+            "uptime" => ->(n) { -(n.uptime || 0) }
+          }.freeze
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Node, nil] repository (default: create new)
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Lists nodes with optional filtering and sorting.
+          #
+          # @param node [String, nil] not used for nodes (included for interface)
+          # @param name [String, nil] filter by exact node name
+          # @param args [Array<String>] unused, for interface compatibility
+          # @param storage [String, nil] unused, for interface compatibility
+          # @param filter [Hash, nil] filter criteria (e.g., { status: "online" })
+          # @param sort [String, nil] sort field (name, status, cpu, memory, disk, guests, uptime)
+          # @param include_details [Boolean] fetch extended details (version, load), default true
+          # @return [Array<Models::Node>] collection of Node models
+          def list(node: nil, name: nil, args: [], storage: nil, filter: nil, sort: nil, include_details: true, **_options)
+            nodes = repository.list(include_details: include_details)
+
+            # Filter by name
+            nodes = nodes.select { |n| n.name == name } if name
+
+            # Apply filters
+            nodes = apply_filters(nodes, filter) if filter
+
+            # Apply sorting
+            nodes = apply_sort(nodes, sort) if sort
+
+            nodes
+          end
+
+          # Returns presenter for nodes.
+          #
+          # @return [Presenters::Node] Node presenter instance
+          def presenter
+            Pvectl::Presenters::Node.new
+          end
+
+          # Describes a single node with comprehensive details.
+          #
+          # @param name [String] node name
+          # @param node [String, nil] unused, for API consistency
+          # @return [Models::Node] Node model with full details
+          # @raise [ArgumentError] if node name is invalid
+          # @raise [Pvectl::ResourceNotFoundError] if node not found
+          def describe(name:, node: nil, args: [], vmid: nil)
+            raise ArgumentError, "Invalid node name" unless valid_node_name?(name)
+
+            node = repository.describe(name)
+            raise Pvectl::ResourceNotFoundError, "Node not found: #{name}" if node.nil?
+
+            node
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Node] Node repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Node] configured Node repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Node.new(connection)
+          end
+
+          # Applies filter criteria to nodes collection.
+          #
+          # @param nodes [Array<Models::Node>] nodes to filter
+          # @param filter [Hash] filter criteria (e.g., { status: "online" })
+          # @return [Array<Models::Node>] filtered nodes
+          def apply_filters(nodes, filter)
+            filter.each do |key, value|
+              case key.to_s
+              when "status"
+                nodes = nodes.select { |n| n.status == value }
+              end
+            end
+            nodes
+          end
+
+          # Applies sorting to nodes collection.
+          #
+          # @param nodes [Array<Models::Node>] nodes to sort
+          # @param sort_field [String] field to sort by
+          # @return [Array<Models::Node>] sorted nodes
+          def apply_sort(nodes, sort_field)
+            sort_proc = SORT_FIELDS[sort_field.to_s]
+            return nodes unless sort_proc
+
+            nodes.sort_by(&sort_proc)
+          end
+
+          # Validates node name format.
+          #
+          # Proxmox node names are alphanumeric, can contain hyphens,
+          # must start with alphanumeric character, max 63 characters.
+          #
+          # @param name [String, nil] node name to validate
+          # @return [Boolean] true if valid
+          def valid_node_name?(name)
+            return false if name.nil? || name.empty?
+
+            # Proxmox node names: alphanumeric, can contain hyphens, max 63 chars
+            name.match?(/\A[a-zA-Z0-9][-a-zA-Z0-9]{0,62}\z/)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "nodes",
+  Pvectl::Commands::Get::Handlers::Nodes,
+  aliases: ["node"]
+)

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing systemd services on Proxmox nodes.
+        #
+        # Implements ResourceHandler interface for the "services" resource type.
+        # Uses Repositories::Service for data access and Presenters::Service
+        # for formatting.
+        #
+        # When no node filter is supplied, lists services across all online
+        # nodes. The --node flag restricts the listing to a single node.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("services")
+        #   services = handler.list(node: "pve1")
+        #
+        # @see Pvectl::Repositories::Service Service repository
+        # @see Pvectl::Presenters::Service Service presenter
+        #
+        class Services
+          include ResourceHandler
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Service, nil] repository (default: build new)
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Lists services, optionally filtered by node and service name.
+          #
+          # @param node [String, nil] filter by node name
+          # @param name [String, nil] filter by service identifier (exact match)
+          # @param _options [Hash] additional CLI options (unused)
+          # @return [Array<Models::Service>] collection of Service models
+          def list(node: nil, name: nil, **_options)
+            services = repository.list(node: node)
+            services = services.select { |s| s.service == name } if name
+            services
+          end
+
+          # Returns presenter for services.
+          #
+          # @return [Presenters::Service] Service presenter instance
+          def presenter
+            Pvectl::Presenters::Service.new
+          end
+
+          private
+
+          # Returns repository, creating it lazily if not injected.
+          #
+          # @return [Repositories::Service] Service repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Service] configured Service repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Service.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "services",
+  Pvectl::Commands::Get::Handlers::Services,
+  aliases: ["svc"]
+)

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing and describing snapshots.
+        #
+        # Uses --vmid flag (repeatable) for VM/CT filtering and --node for node filtering.
+        # Without --vmid, operates cluster-wide.
+        #
+        # @example List snapshots for specific VMs
+        #   handler.list(args: [], vmid: ["100", "101"])
+        #
+        # @example List all snapshots cluster-wide
+        #   handler.list(args: [])
+        #
+        class Snapshots
+          include ResourceHandler
+
+          def initialize(service: nil)
+            @service = service
+          end
+
+          # Lists snapshots, optionally filtered by VMIDs and/or node.
+          #
+          # @param vmid [Array<String>, nil] VM/CT IDs from --vmid flag
+          # @param node [String, nil] node name from --node flag
+          # @param args [Array<String>] unused positional args
+          # @return [Array<Models::Snapshot>] collection of snapshot models
+          def list(node: nil, name: nil, args: [], storage: nil, vmid: nil, **_options)
+            parsed_vmids = parse_vmids(vmid)
+            service.list(parsed_vmids, node: node)
+          end
+
+          # Describes a snapshot by name.
+          #
+          # @param name [String] snapshot name to find
+          # @param vmid [Array<String>, nil] VM/CT IDs from --vmid flag
+          # @param node [String, nil] node name from --node flag
+          # @param args [Array<String>] unused positional args
+          # @return [Models::SnapshotDescription] snapshot description
+          def describe(name:, node: nil, args: [], vmid: nil, **_options)
+            parsed_vmids = parse_vmids(vmid)
+            service.describe(parsed_vmids, name, node: node)
+          end
+
+          # Returns presenter for snapshots.
+          #
+          # @return [Presenters::Snapshot] snapshot presenter instance
+          def presenter
+            Pvectl::Presenters::Snapshot.new
+          end
+
+          private
+
+          # Parses --vmid flag values to integer array.
+          #
+          # @param vmid [Array<String>, String, nil] raw vmid values
+          # @return [Array<Integer>] parsed VMIDs (empty array if nil)
+          def parse_vmids(vmid)
+            return [] if vmid.nil?
+
+            Array(vmid).map(&:to_i)
+          end
+
+          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)
+
+            snapshot_repo = Pvectl::Repositories::Snapshot.new(connection)
+            resolver = Pvectl::Utils::ResourceResolver.new(connection)
+            task_repo = Pvectl::Repositories::Task.new(connection)
+
+            Pvectl::Services::Snapshot.new(
+              snapshot_repo: snapshot_repo,
+              resource_resolver: resolver,
+              task_repo: task_repo
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "snapshots",
+  Pvectl::Commands::Get::Handlers::Snapshots,
+  aliases: ["snapshot", "snap"]
+)

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing Proxmox cluster storage pools.
+        #
+        # Implements ResourceHandler interface for the "storages" resource type
+        # (with "storage" and "stor" as aliases).
+        # Uses Repositories::Storage for data access and Presenters::Storage for formatting.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("storages")
+        #   storage_pools = handler.list(node: "pve1")
+        #
+        # @see Pvectl::Commands::Get::ResourceHandler Handler interface
+        # @see Pvectl::Repositories::Storage Storage repository
+        # @see Pvectl::Presenters::Storage Storage presenter
+        #
+        class Storage
+          include ResourceHandler
+
+          # Creates handler with optional repository for dependency injection.
+          #
+          # @param repository [Repositories::Storage, nil] repository (default: create new)
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # Lists storage pools with optional filtering.
+          #
+          # @param node [String, nil] filter by node name
+          # @param name [String, nil] filter by storage name
+          # @param args [Array<String>] unused, for interface compatibility
+          # @param storage [String, nil] unused, for interface compatibility (storage is filtered via name)
+          # @return [Array<Models::Storage>] collection of Storage models
+          def list(node: nil, name: nil, args: [], storage: nil, **_options)
+            storage_pools = repository.list(node: node)
+            storage_pools = storage_pools.select { |s| s.name == name } if name
+            storage_pools
+          end
+
+          # Returns presenter for storage pools.
+          #
+          # @return [Presenters::Storage] Storage presenter instance
+          def presenter
+            Pvectl::Presenters::Storage.new
+          end
+
+          # Describes a single storage pool by name.
+          #
+          # For local storage (exists on multiple nodes):
+          # - Without node: returns array of instances (which nodes have it)
+          # - With node: returns full describe for that specific node
+          #
+          # For shared storage: returns full describe (single instance).
+          #
+          # @param name [String] storage name
+          # @param node [String, nil] filter by node name (required for local storage)
+          # @return [Models::Storage, Array<Models::Storage>] Storage model or array of instances
+          # @raise [ArgumentError] if storage name is invalid
+          # @raise [Pvectl::ResourceNotFoundError] if storage not found
+          def describe(name:, node: nil, args: [], vmid: nil)
+            raise ArgumentError, "Invalid storage name" if name.nil? || name.empty?
+
+            # Check if storage exists on multiple nodes (local storage)
+            instances = repository.list_instances(name)
+            raise Pvectl::ResourceNotFoundError, "Storage not found: #{name}" if instances.empty?
+
+            if instances.size > 1 && node.nil?
+              # Return list of instances instead of single describe
+              return instances
+            end
+
+            # Single instance or node specified - full describe
+            storage = repository.describe(name, node: node)
+            unless storage
+              if node
+                raise Pvectl::ResourceNotFoundError, "Storage '#{name}' not found on node '#{node}'"
+              else
+                raise Pvectl::ResourceNotFoundError, "Storage not found: #{name}"
+              end
+            end
+
+            storage
+          end
+
+          private
+
+          # Returns repository, creating it if necessary.
+          #
+          # @return [Repositories::Storage] Storage repository
+          def repository
+            @repository ||= build_repository
+          end
+
+          # Builds repository with connection from config.
+          #
+          # @return [Repositories::Storage] configured Storage repository
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Storage.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "storages",
+  Pvectl::Commands::Get::Handlers::Storage,
+  aliases: ["storage", "stor"]
+)

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for `pvectl get subscription`.
+        #
+        # Aggregates subscription records across cluster nodes via
+        # Repositories::Subscription. Supports filtering to a single node
+        # with `--node`.
+        #
+        # @see Pvectl::Repositories::Subscription
+        # @see Pvectl::Presenters::Subscription
+        #
+        class Subscription
+          include ResourceHandler
+
+          # @param repository [Repositories::Subscription, nil]
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          # @param node [String, nil] limit to a single node
+          # @return [Array<Models::Subscription>]
+          def list(node: nil, name: nil, args: [], storage: nil, **_options)
+            repository.list(node: node)
+          end
+
+          # @return [Presenters::Subscription]
+          def presenter
+            Pvectl::Presenters::Subscription.new
+          end
+
+          # @param name [String] node name to describe
+          # @return [Models::Subscription]
+          # @raise [Pvectl::ResourceNotFoundError] when the record cannot be fetched
+          def describe(name:, node: nil, args: [], vmid: nil)
+            raise ArgumentError, "Invalid node name" if name.nil? || name.empty?
+
+            record = repository.get(name)
+            raise Pvectl::ResourceNotFoundError, "Subscription not found for node: #{name}" if record.nil?
+
+            record
+          end
+
+          private
+
+          def repository
+            @repository ||= build_repository
+          end
+
+          def build_repository
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+            Pvectl::Repositories::Subscription.new(connection)
+          end
+        end
+      end
+    end
+  end
+end
+
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "subscription",
+  Pvectl::Commands::Get::Handlers::Subscription,
+  aliases: ["subscriptions", "sub"]
+)

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      module Handlers
+        # Handler for listing Proxmox tasks (async operations).
+        #
+        # Implements ResourceHandler interface for the "tasks" resource type.
+        # Delegates to Services::TaskListing for multi-node task listing.
+        #
+        # @example Using via ResourceRegistry
+        #   handler = ResourceRegistry.for("tasks")
+        #   tasks = handler.list(node: "pve1", limit: 20)
+        #   presenter = handler.presenter
+        #
+        # @see Pvectl::Services::TaskListing Shared task listing service
+        # @see Pvectl::Presenters::TaskEntry Task entry presenter
+        #
+        class Tasks
+          include ResourceHandler
+
+          # Creates handler with optional service for dependency injection.
+          #
+          # @param service [Services::TaskListing, nil] task listing service
+          def initialize(service: nil)
+            @service = service
+          end
+
+          # Lists tasks with optional filtering.
+          #
+          # @param node [String, nil] filter by node name (nil = all nodes)
+          # @param name [String, nil] unused, for interface compatibility
+          # @param limit [Integer] max entries (default 50)
+          # @param since [String, nil] start time filter
+          # @param until_time [String, nil] end time filter
+          # @param type_filter [String, nil] task type filter
+          # @param status_filter [String, nil] status filter
+          # @return [Array<Models::TaskEntry>] task entries
+          def list(node: nil, name: nil, limit: 50, since: nil, until_time: nil,
+                   type_filter: nil, status_filter: nil, **_options)
+            service.list(
+              node: node, vmid: nil, limit: limit, since: since,
+              until_time: until_time, type_filter: type_filter,
+              status_filter: status_filter
+            )
+          end
+
+          # Returns presenter for task entries.
+          #
+          # @return [Presenters::TaskEntry] task entry presenter instance
+          def presenter
+            Pvectl::Presenters::TaskEntry.new
+          end
+
+          private
+
+          # Returns service, creating it if necessary.
+          #
+          # @return [Services::TaskListing] task listing service
+          def service
+            @service ||= build_service
+          end
+
+          # Builds service with repositories from config.
+          #
+          # @return [Services::TaskListing] configured service
+          def build_service
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            connection = Pvectl::Connection.new(config_service.current_config)
+
+            Pvectl::Services::TaskListing.new(
+              task_list_repository: Pvectl::Repositories::TaskList.new(connection),
+              node_repository: Pvectl::Repositories::Node.new(connection)
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register handler with ResourceRegistry
+Pvectl::Commands::Get::ResourceRegistry.register(
+  "tasks",
+  Pvectl::Commands::Get::Handlers::Tasks,
+  aliases: ["task"]
+)