pvectl 0.2.0

data/lib/pvectl/presenters/apt_package.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for APT packages (pending updates and installed versions).
+    #
+    # Standard columns highlight the upgrade path; wide columns add metadata
+    # useful when triaging updates.
+    #
+    # @example Using with formatter
+    #   presenter = AptPackage.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(packages, presenter)
+    #
+    # @see Pvectl::Models::AptPackage AptPackage model
+    #
+    class AptPackage < Base
+      # Returns column headers for standard table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        %w[NODE PACKAGE CURRENT AVAILABLE ORIGIN]
+      end
+
+      # Returns additional column headers for wide output.
+      #
+      # @return [Array<String>] extra column headers
+      def extra_columns
+        %w[ARCH SECTION PRIORITY DESCRIPTION]
+      end
+
+      # Converts AptPackage model to table row values.
+      #
+      # @param model [Models::AptPackage] package model
+      # @param context [Hash] optional context
+      # @return [Array<String>] row values matching columns order
+      def to_row(model, **_context)
+        [
+          model.node || "-",
+          model.package || "-",
+          model.old_version || "-",
+          model.version || "-",
+          model.origin || "-"
+        ]
+      end
+
+      # Returns additional values for wide output.
+      #
+      # @param model [Models::AptPackage] package model
+      # @param context [Hash] optional context
+      # @return [Array<String>] extra values matching extra_columns order
+      def extra_values(model, **_context)
+        [
+          model.arch || "-",
+          model.section || "-",
+          model.priority || "-",
+          truncate(model.description, 60)
+        ]
+      end
+
+      # Converts AptPackage model to hash for JSON/YAML output.
+      #
+      # @param model [Models::AptPackage] package model
+      # @return [Hash] hash representation with string keys
+      def to_hash(model)
+        {
+          "node" => model.node,
+          "package" => model.package,
+          "title" => model.title,
+          "current_version" => model.old_version,
+          "available_version" => model.version,
+          "origin" => model.origin,
+          "arch" => model.arch,
+          "section" => model.section,
+          "priority" => model.priority,
+          "description" => model.description,
+          "notify_status" => model.notify_status,
+          "current_state" => model.current_state,
+          "manager_version" => model.manager_version,
+          "running_kernel" => model.running_kernel
+        }
+      end
+
+      private
+
+      # Truncates text to fit in a column.
+      #
+      # @param text [String, nil] text to truncate
+      # @param length [Integer] maximum length
+      # @return [String] truncated text or "-"
+      def truncate(text, length)
+        return "-" if text.nil? || text.empty?
+        return text if text.length <= length
+
+        "#{text[0, length - 1]}…"
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/backup.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for Backup models.
+    #
+    # Formats backups for table, wide, JSON, and YAML output.
+    # Standard columns: VMID, TYPE, CREATED, SIZE, STORAGE, PROTECTED
+    # Wide columns add: FORMAT, NOTES, VOLID
+    #
+    # @example Using with formatter
+    #   presenter = Backup.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(backups, presenter)
+    #
+    # @see Pvectl::Models::Backup Backup model
+    # @see Pvectl::Formatters::Table Table formatter
+    #
+    class Backup < Base
+      # Returns column headers for standard table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        %w[VMID TYPE CREATED SIZE STORAGE PROTECTED]
+      end
+
+      # Returns additional column headers for wide output.
+      #
+      # @return [Array<String>] extra column headers
+      def extra_columns
+        %w[FORMAT NOTES VOLID]
+      end
+
+      # Converts Backup model to table row values.
+      #
+      # @param model [Models::Backup] Backup model
+      # @param context [Hash] optional context
+      # @return [Array] row values matching columns order
+      def to_row(model, **_context)
+        [
+          model.vmid,
+          format_type(model.resource_type),
+          format_time(model.created_at),
+          model.human_size,
+          model.storage,
+          format_protected(model.protected?)
+        ]
+      end
+
+      # Returns additional values for wide output.
+      #
+      # @param model [Models::Backup] Backup model
+      # @param context [Hash] optional context
+      # @return [Array] extra values matching extra_columns order
+      def extra_values(model, **_context)
+        [
+          model.format,
+          truncate(model.notes, 30),
+          model.volid
+        ]
+      end
+
+      # Converts Backup model to hash for JSON/YAML output.
+      #
+      # @param model [Models::Backup] Backup model
+      # @return [Hash] hash representation with string keys
+      def to_hash(model)
+        {
+          "vmid" => model.vmid,
+          "type" => format_type(model.resource_type),
+          "volid" => model.volid,
+          "storage" => model.storage,
+          "node" => model.node,
+          "size" => model.size,
+          "size_human" => model.human_size,
+          "created_at" => model.created_at&.iso8601,
+          "format" => model.format,
+          "notes" => model.notes,
+          "protected" => model.protected?
+        }
+      end
+
+      private
+
+      # Formats resource type for display.
+      #
+      # @param resource_type [Symbol, nil] :qemu or :lxc
+      # @return [String] formatted type
+      def format_type(resource_type)
+        case resource_type
+        when :qemu then "qemu"
+        when :lxc then "lxc"
+        else "-"
+        end
+      end
+
+      # Formats time for display.
+      #
+      # @param time [Time, nil] time to format
+      # @return [String] formatted time or "-" if nil
+      def format_time(time)
+        return "-" if time.nil?
+
+        time.strftime("%Y-%m-%d %H:%M:%S")
+      end
+
+      # Formats protected status for display.
+      #
+      # @param protected [Boolean] protection status
+      # @return [String] "yes" or "no"
+      def format_protected(protected_status)
+        protected_status ? "yes" : "no"
+      end
+
+      # Truncates text to specified length.
+      #
+      # @param text [String, nil] text to truncate
+      # @param max_length [Integer] maximum length
+      # @return [String, nil] truncated text or nil
+      def truncate(text, max_length)
+        return nil if text.nil?
+        return text if text.length <= max_length
+
+        "#{text[0, max_length - 3]}..."
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/base.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Abstract base class for resource presenters.
+    #
+    # Presenters define how models are displayed in different formats.
+    # Each resource type (VM, Container, Node, etc.) has its own presenter.
+    #
+    # @abstract Subclass and implement {#columns}, {#to_row}, and {#to_hash}.
+    #
+    # @example Implementing a resource presenter
+    #   class VmPresenter < Base
+    #     def columns
+    #       ["NAME", "STATUS", "NODE"]
+    #     end
+    #
+    #     def extra_columns
+    #       ["MEMORY", "CPU"]
+    #     end
+    #
+    #     def to_row(model, **context)
+    #       [model.name, model.status, model.node]
+    #     end
+    #
+    #     def extra_values(model, **context)
+    #       [model.memory, model.cpu]
+    #     end
+    #
+    #     def to_hash(model)
+    #       { "name" => model.name, "status" => model.status, "node" => model.node }
+    #     end
+    #   end
+    #
+    # @see Pvectl::Formatters::OutputHelper for using presenters with formatters
+    #
+    class Base
+      # Returns column headers for table format.
+      #
+      # @return [Array<String>] column names (uppercase, e.g., ["NAME", "STATUS"])
+      # @raise [NotImplementedError] if not implemented by subclass
+      def columns
+        raise NotImplementedError, "#{self.class}#columns must be implemented"
+      end
+
+      # Returns extended column headers for wide format.
+      # By default, appends extra_columns to columns.
+      #
+      # @return [Array<String>] column names (normal + extra)
+      def wide_columns
+        columns + extra_columns
+      end
+
+      # Returns additional columns for wide format.
+      # Override in subclass to add extra columns.
+      #
+      # @return [Array<String>] extra column names (empty by default)
+      def extra_columns
+        []
+      end
+
+      # Converts model to table row values.
+      #
+      # @param model [Object] domain model object
+      # @param context [Hash] optional context (e.g., current_context: "prod")
+      # @return [Array<String, nil>] row values matching columns order
+      # @raise [NotImplementedError] if not implemented by subclass
+      def to_row(model, **context)
+        raise NotImplementedError, "#{self.class}#to_row must be implemented"
+      end
+
+      # Converts model to wide table row values.
+      # By default, appends extra_values to to_row.
+      #
+      # @param model [Object] domain model object
+      # @param context [Hash] optional context
+      # @return [Array<String, nil>] row values (normal + extra)
+      def to_wide_row(model, **context)
+        to_row(model, **context) + extra_values(model, **context)
+      end
+
+      # Returns additional values for wide format.
+      # Override in subclass to add extra values.
+      #
+      # @param model [Object] domain model object
+      # @param context [Hash] optional context
+      # @return [Array<String, nil>] extra values (empty by default)
+      def extra_values(model, **context)
+        []
+      end
+
+      # Converts model to hash for JSON/YAML format.
+      #
+      # @param model [Object] domain model object
+      # @return [Hash] hash representation with string keys
+      # @raise [NotImplementedError] if not implemented by subclass
+      def to_hash(model)
+        raise NotImplementedError, "#{self.class}#to_hash must be implemented"
+      end
+
+      # Converts model to description format (kubectl-style vertical layout).
+      # By default, delegates to to_hash. Override for custom describe output.
+      #
+      # @param model [Object] domain model object
+      # @return [Hash] hash representation (keys become labels)
+      def to_description(model)
+        to_hash(model)
+      end
+
+      # Returns uptime in human-readable format.
+      # Delegates to resource.uptime. Override in subclasses with custom logic.
+      #
+      # @return [String] formatted uptime (e.g., "15d 3h") or "-"
+      def uptime_human
+        uptime = resource.uptime
+        return "-" if uptime.nil? || uptime.zero?
+
+        days = uptime / 86_400
+        hours = (uptime % 86_400) / 3600
+        minutes = (uptime % 3600) / 60
+
+        if days.positive?
+          "#{days}d #{hours}h"
+        elsif hours.positive?
+          "#{hours}h #{minutes}m"
+        else
+          "#{minutes}m"
+        end
+      end
+
+      # Returns tags as array.
+      #
+      # @return [Array<String>] array of tags, or empty array if no tags
+      def tags_array
+        tags = resource.tags
+        return [] if tags.nil? || tags.empty?
+
+        tags.split(";").map(&:strip)
+      end
+
+      # Returns tags as comma-separated string.
+      #
+      # @return [String] formatted tags (e.g., "prod, web") or "-" if no tags
+      def tags_display
+        arr = tags_array
+        arr.empty? ? "-" : arr.join(", ")
+      end
+
+      # Returns template display string.
+      #
+      # @return [String] "yes" if template, "-" otherwise
+      def template_display
+        resource.template? ? "yes" : "-"
+      end
+
+      private
+
+      # Returns the current resource model.
+      # Must be implemented by subclasses.
+      #
+      # @return [Object] current model
+      # @raise [NotImplementedError] if not implemented
+      def resource
+        raise NotImplementedError, "#{self.class}#resource must be implemented"
+      end
+
+      # Formats task history for describe output.
+      #
+      # @param tasks [Array<Models::TaskEntry>, nil] recent tasks
+      # @return [Array<Hash>, String] table data or "No task history"
+      def format_task_history(tasks)
+        return "No task history" if tasks.nil? || tasks.empty?
+
+        tasks.map do |task|
+          start = task.starttime ? Time.at(task.starttime).strftime("%Y-%m-%d %H:%M:%S") : "-"
+          dur = task.duration ? "#{task.duration}s" : "-"
+          {
+            "TYPE" => task.type || "-",
+            "STATUS" => task.exitstatus || task.status || "-",
+            "DATE" => start,
+            "DURATION" => dur,
+            "USER" => task.user || "-"
+          }
+        end
+      end
+
+      # Formats Firewall section from dedicated API data.
+      #
+      # Shows firewall options, rules, aliases, and IP sets
+      # from the /firewall/ API endpoints. Shared by VM and CT presenters.
+      #
+      # @param firewall_data [Hash, nil] firewall data with :options, :rules, :aliases, :ipset
+      # @return [Hash, String] firewall info or "-" if no data
+      def format_firewall(firewall_data)
+        return "-" if firewall_data.nil? || firewall_data.empty?
+
+        options = firewall_data[:options]
+        options = {} unless options.is_a?(Hash)
+        aliases = firewall_data[:aliases]
+        aliases = [] unless aliases.is_a?(Array)
+        ipset = firewall_data[:ipset]
+        ipset = [] unless ipset.is_a?(Array)
+
+        result = {
+          "Enable" => options[:enable] == 1 ? "Yes" : "No",
+          "Input Policy" => (options[:policy_in] || "DROP").to_s,
+          "Output Policy" => (options[:policy_out] || "ACCEPT").to_s
+        }
+
+        # Optional options
+        result["DHCP"] = options[:dhcp] == 1 ? "Yes" : "No" if options.key?(:dhcp)
+        result["MAC Filter"] = options[:macfilter] == 1 ? "Yes" : "No" if options.key?(:macfilter)
+        result["IP Filter"] = options[:ipfilter] == 1 ? "Yes" : "No" if options.key?(:ipfilter)
+        result["NDP"] = options[:ndp] == 1 ? "Yes" : "No" if options.key?(:ndp)
+        result["Router Advertisement"] = options[:radv] == 1 ? "Yes" : "No" if options.key?(:radv)
+        result["Log Level In"] = options[:log_level_in].to_s if options[:log_level_in] && options[:log_level_in] != "nolog"
+        result["Log Level Out"] = options[:log_level_out].to_s if options[:log_level_out] && options[:log_level_out] != "nolog"
+
+        # Aliases table
+        if aliases.any?
+          result["Aliases"] = aliases.map do |a|
+            { "NAME" => a[:name] || "-", "CIDR" => a[:cidr] || "-", "COMMENT" => a[:comment] || "-" }
+          end
+        end
+
+        # IP Sets table
+        if ipset.any?
+          result["IP Sets"] = ipset.map do |s|
+            { "NAME" => s[:name] || "-", "COMMENT" => s[:comment] || "-" }
+          end
+        end
+
+        result
+      end
+
+      # Formats Firewall Rules section as a standalone table.
+      #
+      # Renders firewall rules with the columns: ENABLED, TYPE, ACTION,
+      # PROTO, SOURCE, DEST, COMMENT. Used as a top-level describe section
+      # for VMs and containers. Empty or missing rules render as "-".
+      #
+      # @param firewall_data [Hash, nil] firewall data with :rules key
+      # @return [Array<Hash>, String] rules table or "-" when empty
+      def format_firewall_rules(firewall_data)
+        return "-" if firewall_data.nil? || firewall_data.empty?
+
+        rules = firewall_data[:rules]
+        rules = [] unless rules.is_a?(Array)
+        return "-" if rules.empty?
+
+        rules.sort_by { |r| r[:pos].to_i }.map do |rule|
+          {
+            "ENABLED" => rule[:enable] == 1 ? "yes" : "no",
+            "TYPE" => rule[:type]&.to_s&.upcase || "-",
+            "ACTION" => rule[:action] || "-",
+            "PROTO" => rule[:proto] || "-",
+            "SOURCE" => (rule[:source].nil? || rule[:source].to_s.empty?) ? "-" : rule[:source],
+            "DEST" => (rule[:dest].nil? || rule[:dest].to_s.empty?) ? "-" : rule[:dest],
+            "COMMENT" => (rule[:comment].nil? || rule[:comment].to_s.empty?) ? "-" : rule[:comment]
+          }
+        end
+      end
+
+      # Formats bytes to human readable string.
+      #
+      # @param bytes [Integer, nil] bytes
+      # @return [String] formatted size
+      def format_bytes(bytes)
+        return "-" if bytes.nil? || bytes.zero?
+
+        if bytes >= 1024 * 1024 * 1024
+          "#{(bytes.to_f / 1024 / 1024 / 1024).round(1)} GiB"
+        elsif bytes >= 1024 * 1024
+          "#{(bytes.to_f / 1024 / 1024).round(1)} MiB"
+        elsif bytes >= 1024
+          "#{(bytes.to_f / 1024).round(1)} KiB"
+        else
+          "#{bytes} B"
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/capability.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for node capabilities (QEMU CPU models, machine types).
+    #
+    # Each Capability becomes one row regardless of kind. The DETAILS
+    # column adapts to the kind: CPU rows show vendor (and the "custom"
+    # marker when applicable), machine rows show the underlying machine
+    # family (q35/i440fx).
+    #
+    # @example Using with formatter
+    #   presenter = Capability.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(capabilities, presenter)
+    #
+    # @see Pvectl::Models::Capability
+    #
+    class Capability < Base
+      # Returns column headers for table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        ["NODE", "KIND", "NAME", "DETAILS"]
+      end
+
+      # Returns extra columns for wide output (machine version, custom flag).
+      #
+      # @return [Array<String>] extra columns
+      def extra_columns
+        ["VERSION"]
+      end
+
+      # Converts capability to a row.
+      #
+      # @param model [Models::Capability]
+      # @param _context [Hash] unused
+      # @return [Array<String>]
+      def to_row(model, **_context)
+        [
+          model.node_name || "-",
+          model.kind.to_s,
+          model.name || "-",
+          details(model)
+        ]
+      end
+
+      # Returns extra values for wide output.
+      #
+      # @param model [Models::Capability]
+      # @param _context [Hash] unused
+      # @return [Array<String>]
+      def extra_values(model, **_context)
+        [model.version || "-"]
+      end
+
+      # Converts capability to a hash for JSON/YAML output.
+      #
+      # Only the fields relevant to the kind are included; unset fields
+      # are omitted to keep the output compact and readable.
+      #
+      # @param model [Models::Capability]
+      # @return [Hash{String => Object}]
+      def to_hash(model)
+        base = {
+          "node" => model.node_name,
+          "kind" => model.kind&.to_s,
+          "name" => model.name
+        }
+
+        case model.kind
+        when :cpu
+          base["vendor"] = model.vendor if model.vendor
+          base["custom"] = model.custom
+        when :machine
+          base["machine_type"] = model.machine_type if model.machine_type
+          base["version"] = model.version if model.version
+          base["changes"] = model.changes if model.changes
+        end
+
+        base
+      end
+
+      private
+
+      # Returns the DETAILS column string.
+      #
+      # @param model [Models::Capability]
+      # @return [String]
+      def details(model)
+        case model.kind
+        when :cpu
+          parts = [model.vendor].compact
+          parts << "custom" if model.custom
+          parts.empty? ? "-" : parts.join(" ")
+        when :machine
+          model.machine_type || "-"
+        else
+          "-"
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/config/context.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    module Config
+      # Presenter for formatting context list output.
+      #
+      # Context presenter provides column definitions and row formatting
+      # for displaying contexts in table, wide table, JSON, and YAML formats.
+      # Inherits from Base to support unified output formatting.
+      #
+      # @example Using with OutputHelper
+      #   presenter = Context.new
+      #   OutputHelper.print(
+      #     data: contexts,
+      #     presenter: presenter,
+      #     format: "table",
+      #     current_context: "production"
+      #   )
+      #
+      # @example Wide format includes DEFAULT-NODE column
+      #   pvectl config get-contexts -o wide
+      #   # CURRENT  NAME        CLUSTER  USER       DEFAULT-NODE
+      #   # *        production  prod     admin@pam  pve1
+      #
+      class Context < Pvectl::Presenters::Base
+        # Returns the column headers for table output.
+        #
+        # @return [Array<String>] column names
+        def columns
+          ["CURRENT", "NAME", "CLUSTER", "USER"]
+        end
+
+        # Returns additional columns for wide format.
+        #
+        # @return [Array<String>] extra column names
+        def extra_columns
+          ["DEFAULT-NODE"]
+        end
+
+        # Converts a context to a table row.
+        #
+        # @param context [Config::Models::Context] context to format
+        # @param current_context [String, nil] name of the current context
+        # @param context_kwargs [Hash] additional context (ignored)
+        # @return [Array<String>] row values
+        def to_row(context, current_context: nil, **context_kwargs)
+          [
+            context.name == current_context ? "*" : "",
+            context.name,
+            context.cluster_ref,
+            context.user_ref
+          ]
+        end
+
+        # Returns additional values for wide format.
+        #
+        # @param context [Config::Models::Context] context to format
+        # @param context_kwargs [Hash] additional context (ignored)
+        # @return [Array<String, nil>] extra values
+        def extra_values(context, **context_kwargs)
+          [context.default_node]
+        end
+
+        # Converts a context to a hash for JSON/YAML output.
+        #
+        # @param context [Config::Models::Context] context to format
+        # @return [Hash] hash representation
+        def to_hash(context)
+          {
+            "name" => context.name,
+            "cluster" => context.cluster_ref,
+            "user" => context.user_ref,
+            "default_node" => context.default_node
+          }
+        end
+      end
+    end
+  end
+end