pvectl 0.2.0

data/lib/pvectl/presenters/time_config.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for node time and timezone settings.
+    #
+    # Renders both the UTC timestamp and the node's local wall clock as
+    # human-readable strings. Proxmox returns `localtime` as seconds-since-epoch
+    # interpreted as if the node's wall clock were UTC, so we format it via
+    # `Time.at(localtime).utc.strftime(...)` to preserve the node's view.
+    #
+    # @example Using with formatter
+    #   presenter = TimeConfig.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(time_configs, presenter)
+    #
+    # @see Pvectl::Models::TimeConfig
+    #
+    class TimeConfig < Base
+      # Date format for timestamp columns.
+      TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+      # Returns column headers for table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        ["NODE", "TIMEZONE", "TIME (UTC)", "LOCAL TIME"]
+      end
+
+      # Converts TimeConfig model to a table row.
+      #
+      # @param model [Models::TimeConfig] time configuration
+      # @param _context [Hash] optional context (unused)
+      # @return [Array<String>] row values matching columns order
+      def to_row(model, **_context)
+        [
+          model.node_name || "-",
+          model.timezone || "-",
+          format_timestamp(model.time),
+          format_timestamp(model.localtime)
+        ]
+      end
+
+      # Converts TimeConfig model to a hash for JSON/YAML output.
+      #
+      # @param model [Models::TimeConfig] time configuration
+      # @return [Hash{String => Object}] hash representation
+      def to_hash(model)
+        {
+          "node" => model.node_name,
+          "timezone" => model.timezone,
+          "time" => model.time,
+          "localtime" => model.localtime,
+          "time_iso" => iso(model.time),
+          "localtime_iso" => iso(model.localtime)
+        }
+      end
+
+      private
+
+      # Formats epoch seconds as a UTC-displayed string.
+      #
+      # Used for both the UTC `time` field and `localtime` (Proxmox encodes
+      # the local wall clock as seconds-since-epoch interpreted as UTC, so the
+      # same formatting produces the correct display in both cases).
+      #
+      # @param epoch [Integer, nil] seconds since 1970-01-01
+      # @return [String] formatted timestamp or "-" when nil
+      def format_timestamp(epoch)
+        return "-" if epoch.nil?
+
+        Time.at(epoch).utc.strftime(TIMESTAMP_FORMAT)
+      end
+
+      # ISO 8601 representation for JSON/YAML output.
+      #
+      # @param epoch [Integer, nil] seconds since 1970-01-01
+      # @return [String, nil] ISO 8601 string or nil when epoch is nil
+      def iso(epoch)
+        return nil if epoch.nil?
+
+        Time.at(epoch).utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/top_container.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for container resource usage metrics (top command).
+    #
+    # Inherits from Presenters::Container for reuse of formatting methods.
+    # Includes TopPresenter for shared metrics display.
+    # Focuses on CPU, memory, swap, disk, and network utilization.
+    #
+    # @example Using with formatter
+    #   presenter = TopContainer.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(containers, presenter)
+    #
+    # @see Pvectl::Presenters::Container Parent presenter
+    # @see Pvectl::Presenters::TopPresenter Shared metrics module
+    # @see Pvectl::Commands::Top::Command Top command
+    #
+    class TopContainer < Container
+      include TopPresenter
+
+      # Returns column headers for standard table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        %w[CTID NAME NODE CPU(cores) CPU% MEMORY MEMORY%]
+      end
+
+      # Returns additional column headers for wide output.
+      #
+      # @return [Array<String>] extra column headers
+      def extra_columns
+        %w[SWAP SWAP% DISK DISK% NETIN NETOUT]
+      end
+
+      # Converts Container model to table row with metrics values.
+      #
+      # @param model [Models::Container] Container model
+      # @param context [Hash] optional context
+      # @return [Array<String>] row values matching columns order
+      def to_row(model, **_context)
+        @container = model
+        [
+          container.vmid.to_s,
+          display_name,
+          container.node,
+          cpu_cores_value(container),
+          cpu_usage_value(container),
+          memory_display,
+          percent_display(container.mem, container.maxmem)
+        ]
+      end
+
+      # Returns additional values for wide output.
+      #
+      # @param model [Models::Container] Container model
+      # @param context [Hash] optional context
+      # @return [Array<String>] extra values matching extra_columns order
+      def extra_values(model, **_context)
+        @container = model
+        [
+          swap_display,
+          percent_display(container.swap, container.maxswap),
+          disk_display,
+          percent_display(container.disk, container.maxdisk),
+          netin_display,
+          netout_display
+        ]
+      end
+
+      # Converts Container model to hash for JSON/YAML output.
+      #
+      # Returns metrics-focused hash without operational info
+      # (no status, template, tags, pool, uptime).
+      #
+      # @param model [Models::Container] Container model
+      # @return [Hash] metrics-focused hash representation
+      def to_hash(model)
+        @container = model
+        {
+          "ctid" => container.vmid,
+          "name" => container.name,
+          "node" => container.node,
+          "cpu" => {
+            "usage_percent" => container.cpu.nil? ? nil : (container.cpu * 100).round,
+            "cores" => container.maxcpu
+          },
+          "memory" => {
+            "used_bytes" => container.mem,
+            "total_bytes" => container.maxmem,
+            "usage_percent" => percent_value(container.mem, container.maxmem)
+          },
+          "swap" => {
+            "used_bytes" => container.swap,
+            "total_bytes" => container.maxswap,
+            "usage_percent" => percent_value(container.swap, container.maxswap)
+          },
+          "disk" => {
+            "used_bytes" => container.disk,
+            "total_bytes" => container.maxdisk,
+            "usage_percent" => percent_value(container.disk, container.maxdisk)
+          },
+          "network" => {
+            "in_bytes" => container.netin,
+            "out_bytes" => container.netout
+          }
+        }
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/top_node.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for node resource usage metrics (top command).
+    #
+    # Inherits from Presenters::Node for reuse of formatting methods.
+    # Focuses on CPU, memory, disk, and swap utilization rather than
+    # operational details (version, kernel, services).
+    #
+    # @example Using with formatter
+    #   presenter = TopNode.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(nodes, presenter)
+    #
+    # @see Pvectl::Presenters::Node Parent presenter
+    # @see Pvectl::Commands::Top::Command Top command
+    #
+    class TopNode < Node
+      include TopPresenter
+
+      # Returns column headers for standard table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        %w[NAME CPU(cores) CPU% MEMORY MEMORY%]
+      end
+
+      # Returns additional column headers for wide output.
+      #
+      # @return [Array<String>] extra column headers
+      def extra_columns
+        %w[DISK DISK% SWAP SWAP% LOAD GUESTS]
+      end
+
+      # Converts Node model to table row with metrics values.
+      #
+      # @param model [Models::Node] Node model
+      # @param context [Hash] optional context
+      # @return [Array<String>] row values matching columns order
+      def to_row(model, **_context)
+        @node = model
+        cores = node.offline? ? "-" : cpu_cores_value(node)
+        [
+          node.name,
+          cores,
+          cpu_percent,
+          memory_display,
+          memory_percent_display(node)
+        ]
+      end
+
+      # Returns additional values for wide output.
+      #
+      # @param model [Models::Node] Node model
+      # @param context [Hash] optional context
+      # @return [Array<String>] extra values matching extra_columns order
+      def extra_values(model, **_context)
+        @node = model
+        [
+          storage_display,
+          percent_display(node.disk, node.maxdisk),
+          swap_display,
+          swap_percent_display(node),
+          load_display,
+          node.guests_total.to_s
+        ]
+      end
+
+      # Converts Node model to hash for JSON/YAML output.
+      #
+      # Returns metrics-focused hash without operational info
+      # (no version, kernel, uptime, alerts, network).
+      #
+      # @param model [Models::Node] Node model
+      # @return [Hash] metrics-focused hash representation
+      def to_hash(model)
+        @node = model
+        {
+          "name" => node.name,
+          "cpu" => {
+            "usage_percent" => node.cpu.nil? ? nil : (node.cpu * 100).round,
+            "cores" => node.maxcpu
+          },
+          "memory" => {
+            "used_bytes" => node.mem,
+            "total_bytes" => node.maxmem,
+            "usage_percent" => memory_percent(node)
+          },
+          "disk" => {
+            "used_bytes" => node.disk,
+            "total_bytes" => node.maxdisk,
+            "usage_percent" => storage_percent(node)
+          },
+          "swap" => {
+            "used_bytes" => node.swap_used,
+            "total_bytes" => node.swap_total,
+            "usage_percent" => swap_percent(node)
+          },
+          "load" => {
+            "avg1" => node.loadavg&.dig(0),
+            "avg5" => node.loadavg&.dig(1),
+            "avg15" => node.loadavg&.dig(2)
+          },
+          "guests" => {
+            "total" => node.guests_total,
+            "vms" => node.guests_vms,
+            "cts" => node.guests_cts
+          }
+        }
+      end
+
+    end
+  end
+end

data/lib/pvectl/presenters/top_presenter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Shared metrics formatting for top command presenters.
+    #
+    # Provides common display methods for CPU cores, CPU usage percentage,
+    # and generic percentage calculations used across TopNode, TopVm,
+    # and TopContainer presenters.
+    #
+    # @example Including in a presenter
+    #   class TopVm < Vm
+    #     include TopPresenter
+    #   end
+    #
+    module TopPresenter
+      # Returns CPU core count for display.
+      #
+      # @param resource [Object] model with maxcpu attribute
+      # @return [String] core count or "-" if unavailable
+      def cpu_cores_value(resource)
+        return "-" if resource.maxcpu.nil?
+
+        resource.maxcpu.to_s
+      end
+
+      # Returns CPU usage as percentage string.
+      #
+      # @param resource [Object] model with cpu attribute (0.0-1.0 fraction)
+      # @return [String] CPU percentage (e.g., "23%") or "-" if unavailable
+      def cpu_usage_value(resource)
+        return "-" if resource.cpu.nil?
+
+        "#{(resource.cpu * 100).round}%"
+      end
+
+      # Returns percentage display string from used/total values.
+      #
+      # @param used [Numeric, nil] used amount
+      # @param total [Numeric, nil] total amount
+      # @return [String] percentage (e.g., "45%") or "-" if unavailable
+      def percent_display(used, total)
+        pct = percent_value(used, total)
+        pct ? "#{pct}%" : "-"
+      end
+
+      # Calculates percentage as integer from used/total values.
+      #
+      # @param used [Numeric, nil] used amount
+      # @param total [Numeric, nil] total amount
+      # @return [Integer, nil] percentage or nil if unavailable
+      def percent_value(used, total)
+        return nil if used.nil? || total.nil? || total.zero?
+
+        ((used.to_f / total) * 100).round
+      end
+    end
+  end
+end

data/lib/pvectl/presenters/top_vm.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Presenters
+    # Presenter for VM resource usage metrics (top command).
+    #
+    # Inherits from Presenters::Vm for reuse of formatting methods.
+    # Includes TopPresenter for shared metrics display.
+    # Focuses on CPU, memory, disk, and network utilization.
+    #
+    # @example Using with formatter
+    #   presenter = TopVm.new
+    #   formatter = Formatters::Table.new
+    #   output = formatter.format(vms, presenter)
+    #
+    # @see Pvectl::Presenters::Vm Parent presenter
+    # @see Pvectl::Presenters::TopPresenter Shared metrics module
+    # @see Pvectl::Commands::Top::Command Top command
+    #
+    class TopVm < Vm
+      include TopPresenter
+
+      # Returns column headers for standard table output.
+      #
+      # @return [Array<String>] column headers
+      def columns
+        %w[VMID NAME NODE CPU(cores) CPU% MEMORY MEMORY%]
+      end
+
+      # Returns additional column headers for wide output.
+      #
+      # @return [Array<String>] extra column headers
+      def extra_columns
+        %w[DISK DISK% NETIN NETOUT]
+      end
+
+      # Converts VM model to table row with metrics values.
+      #
+      # @param model [Models::Vm] VM model
+      # @param context [Hash] optional context
+      # @return [Array<String>] row values matching columns order
+      def to_row(model, **_context)
+        @vm = model
+        [
+          vm.vmid.to_s,
+          display_name,
+          vm.node,
+          cpu_cores_value(vm),
+          cpu_usage_value(vm),
+          memory_display,
+          percent_display(vm.mem, vm.maxmem)
+        ]
+      end
+
+      # Returns additional values for wide output.
+      #
+      # @param model [Models::Vm] VM model
+      # @param context [Hash] optional context
+      # @return [Array<String>] extra values matching extra_columns order
+      def extra_values(model, **_context)
+        @vm = model
+        [
+          disk_display,
+          percent_display(vm.disk, vm.maxdisk),
+          format_bytes(vm.netin),
+          format_bytes(vm.netout)
+        ]
+      end
+
+      # Converts VM model to hash for JSON/YAML output.
+      #
+      # Returns metrics-focused hash without operational info
+      # (no status, template, tags, ha, uptime).
+      #
+      # @param model [Models::Vm] VM model
+      # @return [Hash] metrics-focused hash representation
+      def to_hash(model)
+        @vm = model
+        {
+          "vmid" => vm.vmid,
+          "name" => vm.name,
+          "node" => vm.node,
+          "cpu" => {
+            "usage_percent" => vm.cpu.nil? ? nil : (vm.cpu * 100).round,
+            "cores" => vm.maxcpu
+          },
+          "memory" => {
+            "used_bytes" => vm.mem,
+            "total_bytes" => vm.maxmem,
+            "usage_percent" => percent_value(vm.mem, vm.maxmem)
+          },
+          "disk" => {
+            "used_bytes" => vm.disk,
+            "total_bytes" => vm.maxdisk,
+            "usage_percent" => percent_value(vm.disk, vm.maxdisk)
+          },
+          "network" => {
+            "in_bytes" => vm.netin,
+            "out_bytes" => vm.netout
+          }
+        }
+      end
+    end
+  end
+end