pvectl 0.2.0

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Get
+      # Handles continuous watch mode for the get command.
+      #
+      # Repeatedly executes a block at specified intervals, clearing the
+      # screen between iterations when running in a TTY. Handles SIGINT
+      # for graceful termination.
+      #
+      # @example Basic usage
+      #   loop = WatchLoop.new(interval: 5)
+      #   loop.run { puts Time.now }
+      #
+      # @example With custom interval (clamped to minimum)
+      #   loop = WatchLoop.new(interval: 0.5)  # Will be clamped to 1 second
+      #
+      class WatchLoop
+        # Default refresh interval in seconds.
+        DEFAULT_INTERVAL = 2
+
+        # Minimum allowed refresh interval in seconds.
+        MIN_INTERVAL = 1
+
+        # @return [Integer] the effective refresh interval
+        attr_reader :interval
+
+        # Creates a new WatchLoop.
+        #
+        # @param interval [Integer, Float] refresh interval in seconds
+        #   Values below MIN_INTERVAL are automatically clamped.
+        # @param output [IO] output stream for TTY detection (default: $stdout)
+        def initialize(interval: DEFAULT_INTERVAL, output: $stdout)
+          @interval = [interval.to_i, MIN_INTERVAL].max
+          @output = output
+          @running = false
+        end
+
+        # Runs the watch loop, executing the block repeatedly.
+        #
+        # @yield Block to execute on each iteration
+        # @return [void]
+        #
+        # @example
+        #   loop.run do
+        #     models = handler.list
+        #     puts format(models)
+        #   end
+        def run
+          @running = true
+          setup_signal_handler
+
+          while @running
+            clear_screen if tty?
+            print_header if tty?
+            yield
+            sleep_interruptible(@interval)
+          end
+        end
+
+        # Stops the watch loop.
+        #
+        # @return [void]
+        def stop
+          @running = false
+        end
+
+        # Checks if the loop is currently running.
+        #
+        # @return [Boolean] true if running
+        def running?
+          @running
+        end
+
+        private
+
+        # Clears the terminal screen using ANSI escape codes.
+        #
+        # @return [void]
+        def clear_screen
+          @output.print "\e[H\e[2J"
+        end
+
+        # Prints the watch mode header with timestamp.
+        #
+        # @return [void]
+        def print_header
+          timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+          @output.puts "Every #{@interval}s: #{timestamp}"
+          @output.puts
+        end
+
+        # Checks if output is a TTY.
+        #
+        # @return [Boolean] true if output is a TTY
+        def tty?
+          @output.tty?
+        end
+
+        # Sets up SIGINT handler for graceful termination.
+        #
+        # @return [void]
+        def setup_signal_handler
+          @previous_handler = trap("INT") do
+            stop
+            # Don't print newline in non-TTY mode to avoid extra output
+            @output.puts if tty?
+          end
+        end
+
+        # Sleeps for the specified duration, allowing interruption.
+        #
+        # Uses small sleep intervals to allow quick response to stop signal.
+        #
+        # @param duration [Integer] total sleep duration in seconds
+        # @return [void]
+        def sleep_interruptible(duration)
+          remaining = duration
+          while remaining > 0 && @running
+            chunk = [remaining, 0.1].min
+            sleep(chunk)
+            remaining -= chunk
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/irreversible_command.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for irreversible batch commands (delete, template).
+    #
+    # Provides the generic flow: resolve resources → confirm → execute → format results.
+    # Submodules override hooks to customize behavior per operation.
+    #
+    # @example Including in an operation-specific module
+    #   module TemplateCommand
+    #     include IrreversibleCommand
+    #
+    #     def self.included(base)
+    #       base.extend(IrreversibleCommand::ClassMethods)
+    #     end
+    #   end
+    #
+    module IrreversibleCommand
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the command.
+        #
+        # @param resource_type [String, nil] resource type (vm, container)
+        # @param resource_ids [Array<String>, String, nil] resource identifiers
+        # @param options [Hash] command options
+        # @param global_options [Hash] global CLI options
+        # @return [Integer] exit code
+        def execute(resource_type, resource_ids, options, global_options)
+          new(resource_type, resource_ids, options, global_options).execute
+        end
+      end
+
+      # Hook called when module is included.
+      #
+      # @param base [Module] the module or class including this module
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Initializes an irreversible command.
+      #
+      # @param resource_type [String, nil] resource type (vm, container)
+      # @param resource_ids [Array<String>, String, nil] resource identifiers
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(resource_type, resource_ids, options, global_options)
+        @resource_type = resource_type
+        @resource_ids = Array(resource_ids).compact
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the command.
+      #
+      # @return [Integer] exit code
+      def execute
+        return usage_error("Resource type required (#{supported_types.join(', ')})") unless @resource_type
+        return usage_error("Unsupported resource: #{@resource_type}") unless supported_resource?
+
+        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
+
+      # Returns supported resource type strings.
+      #
+      # @return [Array<String>] supported types
+      def supported_types
+        self.class::SUPPORTED_RESOURCES
+      end
+
+      # Checks if resource type is supported.
+      #
+      # @return [Boolean] true if supported
+      def supported_resource?
+        supported_types.include?(@resource_type)
+      end
+
+      # Performs the operation. Override in submodule for custom flow.
+      #
+      # @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?
+        return ExitCodes::SUCCESS unless confirm_operation(resources)
+
+        results = perform_service_call(resources, connection)
+        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 = build_repository(connection)
+
+        resources = if @options[:all]
+                      repo.list(node: @options[:node])
+                    elsif @resource_ids.any?
+                      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
+
+      # Builds the appropriate repository for the resource type.
+      #
+      # @param connection [Connection] API connection
+      # @return [Repositories::Base] repository
+      def build_repository(connection)
+        if resource_type_symbol == :vm
+          Pvectl::Repositories::Vm.new(connection)
+        else
+          Pvectl::Repositories::Container.new(connection)
+        end
+      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 the operation with the user.
+      # Override in submodule for custom confirmation logic.
+      #
+      # @param resources [Array] Resources to operate on
+      # @return [Boolean] true if operation should proceed
+      def confirm_operation(resources)
+        raise NotImplementedError, "#{self.class} must implement #confirm_operation"
+      end
+
+      # Performs the actual service call for the operation.
+      # Must be implemented by the including module.
+      #
+      # @param resources [Array] resources to operate on
+      # @param connection [Connection] API connection
+      # @return [Array<Models::OperationResult>] results
+      def perform_service_call(resources, connection)
+        raise NotImplementedError, "#{self.class} must implement #perform_service_call"
+      end
+
+      # Builds the presenter for results output.
+      # Must be implemented by the including module.
+      #
+      # @return [Presenters::Base] presenter
+      def build_presenter
+        raise NotImplementedError, "#{self.class} must implement #build_presenter"
+      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 base service options from command options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:timeout] = @options[:timeout] if @options[:timeout]
+        opts[:async] = true if @options[:async]
+        opts[:force] = true if @options[:force]
+        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 = build_presenter
+        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/logs/command.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    module Logs
+      # Dispatcher for the `pvectl logs <resource_type> <id>` command.
+      #
+      # Routes requests to appropriate log handlers:
+      # - vm/ct: task history via Handlers::TaskLogs
+      # - node: syslog via Handlers::Syslog (or journal with --journal)
+      # - task: log lines via Handlers::TaskDetail
+      #
+      # @example Basic usage
+      #   Commands::Logs::Command.execute("vm", "100", options, global_options)
+      #
+      class Command
+        # VM/CT resource types that use TaskLogs handler.
+        VM_CT_TYPES = %w[vm vms ct container containers cts].freeze
+
+        # Node resource types.
+        NODE_TYPES = %w[node nodes].freeze
+
+        # Registers the logs command with the CLI.
+        #
+        # @param cli [GLI::App] the CLI application object
+        # @return [void]
+        def self.register(cli)
+          cli.desc "Show logs for resources (task history, syslog, journal)"
+          cli.long_desc <<~HELP
+            Show logs and task history for cluster resources. The log source
+            depends on the resource type:
+
+              vm / container    Task history (start, stop, backup, migrate, etc.)
+              node              System log (syslog by default, --journal for systemd)
+              task              Detailed log output for a specific task UPID
+
+            EXAMPLES
+              Node syslog (last 50 entries):
+                $ pvectl logs node pve1
+
+              Node systemd journal:
+                $ pvectl logs node pve1 --journal
+
+              Task history for a VM:
+                $ pvectl logs vm 100
+
+              Search VM tasks across all nodes:
+                $ pvectl logs vm 100 --all-nodes
+
+              Filter by task type and date:
+                $ pvectl logs vm 100 --type vzdump --since 2026-01-01
+
+              Detailed log for a specific task:
+                $ pvectl logs task UPID:pve1:000ABC:...
+
+              Filter node syslog by service:
+                $ pvectl logs node pve1 --service pvedaemon
+
+              Increase entry limit:
+                $ pvectl logs node pve1 --limit 200
+
+            NOTES
+              Default limit is 50 entries. Task detail (UPID) defaults to 512 lines.
+
+              --all-nodes searches across every cluster node for VM/CT tasks.
+              This is useful when a VM has been migrated between nodes.
+
+              Timestamps for --since and --until accept YYYY-MM-DD format
+              or Unix epoch seconds.
+
+            SEE ALSO
+              pvectl help get tasks     List task history cluster-wide
+              pvectl help describe      Detailed resource information
+          HELP
+          cli.arg_name "RESOURCE_TYPE ID"
+          cli.command :logs do |c|
+            c.desc "Maximum number of entries to show"
+            c.default_value 50
+            c.flag [:limit], type: Integer, arg_name: "N"
+
+            c.desc "Show entries since timestamp (YYYY-MM-DD or epoch)"
+            c.flag [:since], arg_name: "TIMESTAMP"
+
+            c.desc "Show entries until timestamp (YYYY-MM-DD or epoch)"
+            c.flag [:until], arg_name: "TIMESTAMP"
+
+            c.desc "Filter by task type (e.g., qmstart, qmstop, vzdump)"
+            c.flag [:type], arg_name: "TYPE"
+
+            c.desc "Filter by status (running, ok, error)"
+            c.flag [:status], arg_name: "STATUS"
+
+            c.desc "Filter by service name (syslog only)"
+            c.flag [:service], arg_name: "SERVICE"
+
+            c.desc "Use systemd journal instead of syslog (node only)"
+            c.switch [:journal], negatable: false
+
+            c.desc "Search across all cluster nodes (VM/CT only)"
+            c.switch [:"all-nodes"], negatable: false
+
+            c.action do |global_options, options, args|
+              resource_type = args[0]
+              resource_id = args[1]
+              exit_code = execute(resource_type, resource_id, options, global_options)
+              exit exit_code if exit_code != 0
+            end
+          end
+        end
+
+        # Executes the logs command.
+        #
+        # @param resource_type [String, nil] type (vm, ct, node, task)
+        # @param resource_id [String, nil] identifier (VMID, node name, UPID)
+        # @param options [Hash] command options
+        # @param global_options [Hash] global CLI options
+        # @return [Integer] exit code
+        def self.execute(resource_type, resource_id, options, global_options)
+          new(resource_type, resource_id, options, global_options).execute
+        end
+
+        # Creates a new Logs command instance.
+        #
+        # @param resource_type [String, nil] type of resource
+        # @param resource_id [String, nil] resource identifier
+        # @param options [Hash] command options
+        # @param global_options [Hash] global CLI options
+        # @param handler [Object, nil] override handler for testing
+        # @param journal_handler [Object, nil] override journal handler for testing
+        # @param registry [Class] registry for handler lookup
+        def initialize(resource_type, resource_id, options, global_options,
+                       handler: nil, journal_handler: nil,
+                       registry: Logs::ResourceRegistry)
+          @resource_type = resource_type
+          @resource_id = resource_id
+          @options = options
+          @global_options = global_options
+          @handler = handler
+          @journal_handler = journal_handler
+          @registry = registry
+        end
+
+        # Executes the logs operation.
+        #
+        # @return [Integer] exit code
+        def execute
+          return missing_resource_type_error if @resource_type.nil?
+          return missing_resource_id_error if @resource_id.nil? || @resource_id.empty?
+
+          handler = resolve_handler
+          return unknown_resource_error unless handler
+
+          models = fetch_data(handler)
+          output = format_output(models, handler.presenter)
+          puts output
+
+          ExitCodes::SUCCESS
+        rescue ResourceNotFoundError => e
+          $stderr.puts "Error: #{e.message}"
+          ExitCodes::NOT_FOUND
+        rescue Pvectl::Config::ConfigNotFoundError,
+               Pvectl::Config::InvalidConfigError,
+               Pvectl::Config::ContextNotFoundError,
+               Pvectl::Config::ClusterNotFoundError,
+               Pvectl::Config::UserNotFoundError => e
+          $stderr.puts "Error: #{e.message}"
+          ExitCodes::CONFIG_ERROR
+        rescue Timeout::Error, Errno::ECONNREFUSED, SocketError => e
+          $stderr.puts "Error: #{e.message}"
+          ExitCodes::CONNECTION_ERROR
+        end
+
+        private
+
+        # Resolves the handler based on resource type and flags.
+        #
+        # @return [Object, nil] handler instance
+        def resolve_handler
+          return @handler if @handler
+
+          if NODE_TYPES.include?(@resource_type) && @options[:journal]
+            @journal_handler || Handlers::Journal.new
+          else
+            @registry.for(@resource_type)
+          end
+        end
+
+        # Fetches data from the handler with appropriate parameters.
+        #
+        # @param handler [Object] the resolved handler
+        # @return [Array<Object>] models
+        def fetch_data(handler)
+          if VM_CT_TYPES.include?(@resource_type)
+            handler.list(
+              vmid: @resource_id.to_i,
+              resource_type: @resource_type,
+              all_nodes: @options[:"all-nodes"] || false,
+              limit: @options[:limit] || 50,
+              since: @options[:since],
+              until_time: @options[:until],
+              type_filter: @options[:type],
+              status_filter: @options[:status]
+            )
+          elsif NODE_TYPES.include?(@resource_type)
+            handler.list(
+              node: @resource_id,
+              limit: @options[:limit] || 50,
+              since: @options[:since],
+              until_time: @options[:until],
+              service: @options[:service]
+            )
+          elsif @resource_type == "task"
+            handler.list(
+              upid: @resource_id,
+              start: 0,
+              limit: @options[:limit] || 512
+            )
+          else
+            handler.list
+          end
+        end
+
+        # Outputs error for missing resource type argument.
+        #
+        # @return [Integer] USAGE_ERROR exit code
+        def missing_resource_type_error
+          $stderr.puts "Error: resource type is required"
+          $stderr.puts "Usage: pvectl logs RESOURCE_TYPE ID [options]"
+          $stderr.puts "Available resources: vm, ct, node, task"
+          ExitCodes::USAGE_ERROR
+        end
+
+        # Outputs error for missing resource ID argument.
+        #
+        # @return [Integer] USAGE_ERROR exit code
+        def missing_resource_id_error
+          $stderr.puts "Error: resource ID is required"
+          $stderr.puts "Usage: pvectl logs #{@resource_type} ID [options]"
+          ExitCodes::USAGE_ERROR
+        end
+
+        # Outputs error for unknown resource type.
+        #
+        # @return [Integer] USAGE_ERROR exit code
+        def unknown_resource_error
+          $stderr.puts "Unknown resource type: #{@resource_type}"
+          $stderr.puts "Available resources: vm, ct, node, task"
+          ExitCodes::USAGE_ERROR
+        end
+
+        # Formats models for output using the appropriate formatter.
+        #
+        # @param models [Array<Object>] collection of models
+        # @param presenter [Presenters::Base] presenter for the resource type
+        # @return [String] formatted output
+        def format_output(models, presenter)
+          format = @global_options[:output] || "table"
+          color_enabled = determine_color_enabled
+          formatter = Formatters::Registry.for(format)
+          formatter.format(models, presenter, color_enabled: color_enabled)
+        end
+
+        # Determines if color output should be enabled.
+        #
+        # @return [Boolean] true if color should be enabled
+        def determine_color_enabled
+          explicit = @global_options[:color]
+          return explicit unless explicit.nil?
+
+          $stdout.tty?
+        end
+      end
+    end
+  end
+end