pvectl 0.2.0

data/lib/pvectl/commands/logs/handlers/journal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      module Handlers
+        # Handler for node systemd journal output.
+        #
+        # Fetches journal entries from a node via Repositories::Journal.
+        # Not registered in ResourceRegistry — created by Command
+        # when --journal flag is set.
+        #
+        # @see Pvectl::Repositories::Journal Journal repository
+        # @see Pvectl::Presenters::JournalEntry Journal presenter
+        #
+        class Journal
+          include Logs::ResourceHandler
+
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          def list(node:, limit: 50, since: nil, until_time: nil, **_)
+            repository.list(node: node, last_entries: limit, since: since,
+                            until_time: until_time)
+          end
+
+          def presenter
+            Presenters::JournalEntry.new
+          end
+
+          private
+
+          def repository
+            @repository ||= begin
+              config_service = Pvectl::Config::Service.new
+              config_service.load
+              connection = Pvectl::Connection.new(config_service.current_config)
+              Repositories::Journal.new(connection)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/logs/handlers/syslog.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      module Handlers
+        # Handler for node syslog output.
+        #
+        # Fetches syslog entries from a node via Repositories::Syslog.
+        # Supports filtering by service name and time range.
+        #
+        # @example Using via registry
+        #   handler = Logs::ResourceRegistry.for("node")
+        #   entries = handler.list(node: "pve1", service: "pvedaemon")
+        #
+        # @see Pvectl::Repositories::Syslog Syslog repository
+        # @see Pvectl::Presenters::SyslogEntry Syslog presenter
+        #
+        class Syslog
+          include Logs::ResourceHandler
+
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          def list(node:, limit: 50, since: nil, until_time: nil, service: nil, **_)
+            repository.list(node: node, limit: limit, since: since,
+                            until_time: until_time, service: service)
+          end
+
+          def presenter
+            Presenters::SyslogEntry.new
+          end
+
+          private
+
+          def repository
+            @repository ||= begin
+              config_service = Pvectl::Config::Service.new
+              config_service.load
+              connection = Pvectl::Connection.new(config_service.current_config)
+              Repositories::Syslog.new(connection)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pvectl::Commands::Logs::ResourceRegistry.register(
+  "node", Pvectl::Commands::Logs::Handlers::Syslog, aliases: ["nodes"]
+)

data/lib/pvectl/commands/logs/handlers/task_detail.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      module Handlers
+        # Handler for task log drill-down by UPID.
+        #
+        # Fetches individual task log lines from the Proxmox API.
+        # Extracts the node name from the UPID for API routing.
+        #
+        # @example Using via registry
+        #   handler = Logs::ResourceRegistry.for("task")
+        #   lines = handler.list(upid: "UPID:pve1:000ABC:...")
+        #
+        # @see Pvectl::Repositories::TaskLog Task log repository
+        # @see Pvectl::Presenters::TaskLogLine Task log line presenter
+        #
+        class TaskDetail
+          include Logs::ResourceHandler
+
+          def initialize(repository: nil)
+            @repository = repository
+          end
+
+          def list(upid:, start: 0, limit: 512, **_)
+            repository.list(upid: upid, start: start, limit: limit)
+          end
+
+          def presenter
+            Presenters::TaskLogLine.new
+          end
+
+          private
+
+          def repository
+            @repository ||= begin
+              config_service = Pvectl::Config::Service.new
+              config_service.load
+              connection = Pvectl::Connection.new(config_service.current_config)
+              Repositories::TaskLog.new(connection)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pvectl::Commands::Logs::ResourceRegistry.register(
+  "task", Pvectl::Commands::Logs::Handlers::TaskDetail
+)

data/lib/pvectl/commands/logs/handlers/task_logs.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      module Handlers
+        # Handler for VM/CT task history logs.
+        #
+        # Resolves VM/CT node via repository, then delegates task listing
+        # to Services::TaskListing. With --all-nodes, passes node: nil
+        # to the service for cluster-wide iteration.
+        #
+        # @example Using via registry
+        #   handler = Logs::ResourceRegistry.for("vm")
+        #   entries = handler.list(vmid: 100, resource_type: "vm")
+        #
+        # @see Pvectl::Services::TaskListing Shared task listing service
+        # @see Pvectl::Presenters::TaskEntry Task entry presenter
+        #
+        class TaskLogs
+          include Logs::ResourceHandler
+
+          # Maps resource type aliases to repository classes.
+          RESOURCE_REPOS = {
+            "vm" => -> { Pvectl::Repositories::Vm },
+            "vms" => -> { Pvectl::Repositories::Vm },
+            "ct" => -> { Pvectl::Repositories::Container },
+            "container" => -> { Pvectl::Repositories::Container },
+            "containers" => -> { Pvectl::Repositories::Container },
+            "cts" => -> { Pvectl::Repositories::Container }
+          }.freeze
+
+          def initialize(task_list_repository: nil, vm_repository: nil, node_repository: nil)
+            @task_list_repository = task_list_repository
+            @vm_repository = vm_repository
+            @node_repository = node_repository
+          end
+
+          def list(vmid:, resource_type: "vm", all_nodes: false, limit: 50,
+                   since: nil, until_time: nil, type_filter: nil, status_filter: nil, **_)
+            if all_nodes
+              service.list(
+                vmid: vmid, limit: limit, since: since,
+                until_time: until_time, type_filter: type_filter,
+                status_filter: status_filter
+              )
+            else
+              node = resolve_node(vmid, resource_type)
+              service.list(
+                node: node, vmid: vmid, limit: limit, since: since,
+                until_time: until_time, type_filter: type_filter,
+                status_filter: status_filter
+              )
+            end
+          end
+
+          def presenter
+            Presenters::TaskEntry.new
+          end
+
+          private
+
+          def resolve_node(vmid, resource_type)
+            resource = resource_repository(resource_type).get(vmid)
+            raise ResourceNotFoundError, "Resource not found: #{vmid}" unless resource
+
+            resource.node
+          end
+
+          def resource_repository(resource_type)
+            @vm_repository || build_resource_repository(resource_type)
+          end
+
+          def build_resource_repository(resource_type)
+            repo_class = RESOURCE_REPOS.fetch(resource_type, -> { Pvectl::Repositories::Vm }).call
+            connection = build_connection
+            repo_class.new(connection)
+          end
+
+          def service
+            @service ||= Pvectl::Services::TaskListing.new(
+              task_list_repository: task_list_repository,
+              node_repository: node_repository
+            )
+          end
+
+          def task_list_repository
+            @task_list_repository ||= begin
+              connection = build_connection
+              Repositories::TaskList.new(connection)
+            end
+          end
+
+          def node_repository
+            @node_repository ||= begin
+              connection = build_connection
+              Repositories::Node.new(connection)
+            end
+          end
+
+          def build_connection
+            config_service = Pvectl::Config::Service.new
+            config_service.load
+            Pvectl::Connection.new(config_service.current_config)
+          end
+        end
+      end
+    end
+  end
+end
+
+Pvectl::Commands::Logs::ResourceRegistry.register(
+  "vm", Pvectl::Commands::Logs::Handlers::TaskLogs,
+  aliases: ["vms", "ct", "container", "containers", "cts"]
+)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      # Interface module for Logs command handlers.
+      #
+      # Each handler fetches log data from a specific source (task list,
+      # syslog, journal, or task detail) and returns an appropriate presenter.
+      #
+      # @abstract Include in handler class and implement required methods.
+      #
+      # @example Implementing a handler
+      #   class SyslogHandler
+      #     include Logs::ResourceHandler
+      #
+      #     def list(node:, limit: 50, **_)
+      #       repository.list(node: node, limit: limit)
+      #     end
+      #
+      #     def presenter
+      #       Presenters::SyslogEntry.new
+      #     end
+      #   end
+      #
+      module ResourceHandler
+        # Lists log entries with filtering options.
+        #
+        # @param options [Hash] keyword arguments specific to each handler
+        # @return [Array<Object>] collection of model objects
+        # @raise [NotImplementedError] if not implemented by including class
+        def list(**options)
+          raise NotImplementedError, "#{self.class}#list must be implemented"
+        end
+
+        # Returns the presenter for this log 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      # Registry for Logs command resource handlers.
+      #
+      # Inherits registration and lookup from Commands::ResourceRegistry,
+      # maintaining its own isolated set of handlers for log operations.
+      #
+      # @example Registering a handler
+      #   Logs::ResourceRegistry.register("vm", Handlers::TaskLogs, aliases: ["vms"])
+      #
+      # @example Looking up a handler
+      #   handler = Logs::ResourceRegistry.for("vm")
+      #
+      # @see Pvectl::Commands::ResourceRegistry Base registry
+      #
+      class ResourceRegistry < Commands::ResourceRegistry; end
+    end
+  end
+end

data/lib/pvectl/commands/migrate_command.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for migrate commands (migrate vm, migrate container).
+    #
+    # This module extracts common code used by MigrateVm and MigrateContainer.
+    # Pattern: identical to DeleteCommand module but with migrate-specific behavior:
+    # - Requires --target flag (no default)
+    # - Validates --restart only for containers
+    # - Async is default (no --async flag), --wait for sync
+    # - partition_by_target logic is in Service layer
+    #
+    # @example Including in a command class
+    #   class MigrateVm
+    #     include MigrateCommand
+    #     RESOURCE_TYPE = :vm
+    #     SUPPORTED_RESOURCES = %w[vm].freeze
+    #   end
+    #
+    module MigrateCommand
+      # Valid Proxmox node name format: lowercase alphanumeric, starting with letter, hyphens allowed.
+      NODE_NAME_FORMAT = /\A[a-z][a-z0-9-]*\z/
+
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the migrate command.
+        #
+        # @param args [Array<String>] resource identifiers
+        # @param options [Hash] command options
+        # @param global_options [Hash] global CLI options
+        # @return [Integer] exit code
+        def execute(args, options, global_options)
+          new(args, options, global_options).execute
+        end
+      end
+
+      # Hook called when module is included.
+      #
+      # @param base [Class] the class including this module
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Initializes a migrate command.
+      #
+      # @param args [Array<String>] resource identifiers
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(args, options, global_options)
+        @resource_ids = Array(args).compact
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the migrate command.
+      #
+      # @return [Integer] exit code
+      def execute
+        target = @options[:target]
+        return usage_error("--target is required") if target.nil? || target.empty?
+
+        unless target.match?(NODE_NAME_FORMAT)
+          return usage_error("Invalid target node name: #{target}")
+        end
+
+        return usage_error("--restart is only supported for containers") if restart_not_allowed?
+
+        if @resource_ids.empty? && !@options[:all] && selector_strings.empty?
+          return usage_error("VMID, --all, or -l selector required")
+        end
+
+        perform_operation
+      end
+
+      private
+
+      # Returns the resource type symbol (:vm or :container).
+      #
+      # @return [Symbol] resource type
+      def resource_type_symbol
+        self.class::RESOURCE_TYPE
+      end
+
+      # Checks if --restart is used for a non-container resource.
+      #
+      # @return [Boolean] true if restart flag is invalid
+      def restart_not_allowed?
+        @options[:restart] && resource_type_symbol == :vm
+      end
+
+      # Performs the migrate operation.
+      #
+      # @return [Integer] exit code
+      def perform_operation
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        resources = resolve_resources(connection)
+        return no_resources_found if resources.empty?
+
+        target = @options[:target]
+        return ExitCodes::SUCCESS unless confirm_operation(resources, target)
+
+        vm_repo = Pvectl::Repositories::Vm.new(connection)
+        container_repo = Pvectl::Repositories::Container.new(connection)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        service = Pvectl::Services::ResourceMigration.new(
+          vm_repository: vm_repo,
+          container_repository: container_repo,
+          task_repository: task_repo,
+          options: service_options
+        )
+
+        results = service.execute(resource_type_symbol, resources, target: target)
+        return ExitCodes::SUCCESS if results.empty?
+
+        output_results(results)
+        determine_exit_code(results)
+      rescue Pvectl::Config::ConfigNotFoundError,
+             Pvectl::Config::InvalidConfigError,
+             Pvectl::Config::ContextNotFoundError,
+             Pvectl::Config::ClusterNotFoundError,
+             Pvectl::Config::UserNotFoundError
+        raise
+      rescue StandardError => e
+        $stderr.puts "Error: #{e.message}"
+        ExitCodes::GENERAL_ERROR
+      end
+
+      # Resolves resources based on IDs, --all flag, or selectors.
+      #
+      # @param connection [Connection] API connection
+      # @return [Array<Models::Vm, Models::Container>] resolved resources
+      def resolve_resources(connection)
+        repo = resource_type_symbol == :vm ?
+          Pvectl::Repositories::Vm.new(connection) :
+          Pvectl::Repositories::Container.new(connection)
+
+        resources = if @options[:all]
+                      repo.list(node: @options[:node])
+                    elsif @resource_ids.any?
+                      @resource_ids.each do |id|
+                        unless id.match?(/\A\d+\z/)
+                          raise ArgumentError, "Invalid VMID/CTID: #{id}"
+                        end
+                      end
+                      resolved = @resource_ids.map { |id| repo.get(id.to_i) }.compact
+                      resolved = resolved.select { |r| r.node == @options[:node] } if @options[:node]
+                      resolved
+                    else
+                      return [] if selector_strings.empty?
+                      repo.list(node: @options[:node])
+                    end
+
+        apply_selectors(resources)
+      end
+
+      # Returns selector strings from options.
+      #
+      # @return [Array<String>] selector strings
+      def selector_strings
+        Array(@options[:selector] || @options[:l])
+      end
+
+      # Applies selectors to resource collection.
+      #
+      # @param resources [Array] Resources to filter
+      # @return [Array] Filtered resources
+      def apply_selectors(resources)
+        return resources if selector_strings.empty?
+
+        selector_class = resource_type_symbol == :vm ? Selectors::Vm : Selectors::Container
+        selector = selector_class.parse_all(selector_strings)
+        selector.apply(resources)
+      end
+
+      # Confirms migrate operation with user.
+      #
+      # @param resources [Array] Resources to migrate
+      # @param target [String] Target node name
+      # @return [Boolean] true if operation should proceed
+      def confirm_operation(resources, target)
+        return true if @options[:yes]
+
+        type_name = resource_type_symbol == :vm ? "VM" : "container"
+        type_plural = resource_type_symbol == :vm ? "VMs" : "containers"
+
+        if resources.size == 1
+          r = resources.first
+          $stdout.puts "You are about to migrate #{type_name} #{r.vmid} (#{r.name || 'unnamed'}) from #{r.node} to #{target}."
+        else
+          $stdout.puts "You are about to migrate #{resources.size} #{type_plural} to #{target}:"
+          resources.each { |r| $stdout.puts "  - #{r.vmid} (#{r.name || 'unnamed'}) on #{r.node}" }
+        end
+
+        $stdout.puts ""
+        $stdout.puts "This will migrate the #{type_plural} to node #{target}."
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      end
+
+      # Loads configuration from file or environment.
+      #
+      # @return [void]
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: @global_options[:config])
+        @config = service.current_config
+      end
+
+      # Builds service options from command options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:timeout] = @options[:timeout] if @options[:timeout]
+        opts[:wait] = true if @options[:wait]
+        opts[:online] = true if @options[:online]
+        opts[:restart] = true if @options[:restart]
+        opts[:target_storage] = @options[:"target-storage"] if @options[:"target-storage"]
+        opts[:fail_fast] = true if @options[:"fail-fast"]
+        opts
+      end
+
+      # Outputs operation results using the configured formatter.
+      #
+      # @param results [Array<Models::OperationResult>] operation results
+      # @return [void]
+      def output_results(results)
+        presenter = if resource_type_symbol == :vm
+                      Pvectl::Presenters::VmOperationResult.new
+                    else
+                      Pvectl::Presenters::ContainerOperationResult.new
+                    end
+        format = @global_options[:output] || "table"
+        color_flag = @global_options[:color]
+
+        formatter = Pvectl::Formatters::Registry.for(format)
+        output = formatter.format(results, presenter, color: color_flag)
+        puts output
+      end
+
+      # Determines exit code based on results.
+      #
+      # @param results [Array<Models::OperationResult>] operation results
+      # @return [Integer] exit code
+      def determine_exit_code(results)
+        return ExitCodes::SUCCESS if results.all?(&:successful?)
+        return ExitCodes::SUCCESS if results.all?(&:pending?)
+
+        ExitCodes::GENERAL_ERROR
+      end
+
+      # Outputs usage error and returns exit code.
+      #
+      # @param message [String] error message
+      # @return [Integer] exit code
+      def usage_error(message)
+        $stderr.puts "Error: #{message}"
+        ExitCodes::USAGE_ERROR
+      end
+
+      # Outputs no resources found error and returns exit code.
+      #
+      # @return [Integer] exit code
+      def no_resources_found
+        type_plural = resource_type_symbol == :vm ? "VMs" : "containers"
+        msg = if @options[:all] || selector_strings.any?
+                @options[:node] ? "No #{type_plural} found on node #{@options[:node]}" : "No #{type_plural} found matching criteria"
+              else
+                "No #{type_plural} found for given IDs"
+              end
+        $stderr.puts "Error: #{msg}"
+        ExitCodes::NOT_FOUND
+      end
+    end
+  end
+end

data/lib/pvectl/commands/migrate_container.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl migrate container` command.
+    #
+    # Migrates one or more LXC containers to another cluster node.
+    # Always requires --target and confirmation (--yes to skip).
+    #
+    # @example Migrate a single container
+    #   pvectl migrate container 200 --target pve2 --yes
+    #
+    # @example Restart migration
+    #   pvectl migrate container 200 --target pve2 --restart --yes
+    #
+    class MigrateContainer
+      include MigrateCommand
+
+      RESOURCE_TYPE = :container
+      SUPPORTED_RESOURCES = %w[container ct].freeze
+    end
+  end
+end