pvectl 0.2.0

data/lib/pvectl/models/container.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents an LXC container in the Proxmox cluster.
+    #
+    # Immutable domain model containing container attributes and status predicates.
+    # Created by Repositories::Container from API data.
+    # Display/formatting methods are in Presenters::Container.
+    #
+    # @example Creating a Container model
+    #   ct = Container.new(vmid: 100, name: "web", status: "running", node: "pve1")
+    #   ct.running? #=> true
+    #   ct.template? #=> false
+    #
+    # @example From API response
+    #   data = { "vmid" => 100, "name" => "web", "status" => "running" }
+    #   ct = Container.new(data)
+    #
+    # @see Pvectl::Repositories::Container Repository that creates Container instances
+    # @see Pvectl::Presenters::Container Presenter for formatting Container data
+    #
+    class Container < Base
+      # @!group Identifier Attributes
+
+      # @return [Integer] unique container identifier (CTID: 100-999999999)
+      attr_reader :vmid
+
+      # @return [String, nil] container name (hostname)
+      attr_reader :name
+
+      # @return [String] node name where container runs
+      attr_reader :node
+
+      # @return [String] container status (running, stopped)
+      attr_reader :status
+
+      # @!endgroup
+
+      # @!group Resource Attributes
+
+      # @return [Float, nil] current CPU usage (0.0-1.0 scale)
+      attr_reader :cpu
+
+      # @return [Integer, nil] allocated CPU cores
+      attr_reader :maxcpu
+
+      # @return [Integer, nil] current memory usage in bytes
+      attr_reader :mem
+
+      # @return [Integer, nil] memory limit in bytes
+      attr_reader :maxmem
+
+      # @return [Integer, nil] current swap usage in bytes
+      attr_reader :swap
+
+      # @return [Integer, nil] swap limit in bytes
+      attr_reader :maxswap
+
+      # @return [Integer, nil] current rootfs disk usage in bytes
+      attr_reader :disk
+
+      # @return [Integer, nil] rootfs disk limit in bytes
+      attr_reader :maxdisk
+
+      # @!endgroup
+
+      # @!group Metadata Attributes
+
+      # @return [Integer, nil] uptime in seconds
+      attr_reader :uptime
+
+      # @return [Integer, nil] template flag (1 if template, 0 otherwise)
+      attr_reader :template
+
+      # @return [String, nil] semicolon-separated tags
+      attr_reader :tags
+
+      # @return [String, nil] resource pool name
+      attr_reader :pool
+
+      # @return [String, nil] lock status (backup, migrate, etc.)
+      attr_reader :lock
+
+      # @!endgroup
+
+      # @!group Network I/O Attributes
+
+      # @return [Integer, nil] network input bytes
+      attr_reader :netin
+
+      # @return [Integer, nil] network output bytes
+      attr_reader :netout
+
+      # @!endgroup
+
+      # @!group Describe-Only Attributes
+
+      # @return [String, nil] OS type (debian, ubuntu, alpine, etc.)
+      attr_reader :ostype
+
+      # @return [String, nil] architecture (amd64, arm64)
+      attr_reader :arch
+
+      # @return [Integer, nil] unprivileged flag (1 if unprivileged, 0 otherwise)
+      attr_reader :unprivileged
+
+      # @return [String, nil] features configuration (nesting, keyctl, etc.)
+      attr_reader :features
+
+      # @return [String, nil] rootfs configuration string
+      attr_reader :rootfs
+
+      # @return [Array<Hash>] network interface configurations
+      attr_reader :network_interfaces
+
+      # @return [String, nil] container description
+      attr_reader :description
+
+      # @return [String, nil] container hostname (FQDN)
+      attr_reader :hostname
+
+      # @return [Integer, nil] runtime PID
+      attr_reader :pid
+
+      # @return [Hash, nil] HA state information
+      attr_reader :ha
+
+      # @return [String, nil] resource type from API ("lxc")
+      attr_reader :type
+
+      # @return [Hash, nil] raw API responses for describe command
+      attr_reader :describe_data
+
+      # @!endgroup
+
+      # Creates a new Container model from attributes.
+      #
+      # @param attrs [Hash] Container attributes from API (string or symbol keys)
+      def initialize(attrs = {})
+        super(attrs)
+        # Use @attributes which has normalized symbol keys from Base
+        @vmid = @attributes[:vmid]
+        @name = @attributes[:name]
+        @node = @attributes[:node]
+        @status = @attributes[:status]
+        @cpu = @attributes[:cpu]
+        @maxcpu = @attributes[:maxcpu]
+        @mem = @attributes[:mem]
+        @maxmem = @attributes[:maxmem]
+        @swap = @attributes[:swap]
+        @maxswap = @attributes[:maxswap]
+        @disk = @attributes[:disk]
+        @maxdisk = @attributes[:maxdisk]
+        @uptime = @attributes[:uptime]
+        @template = @attributes[:template]
+        @tags = @attributes[:tags]
+        @pool = @attributes[:pool]
+        @lock = @attributes[:lock]
+        @netin = @attributes[:netin]
+        @netout = @attributes[:netout]
+        @ostype = @attributes[:ostype]
+        @arch = @attributes[:arch]
+        @unprivileged = @attributes[:unprivileged]
+        @features = @attributes[:features]
+        @rootfs = @attributes[:rootfs]
+        @network_interfaces = @attributes[:network_interfaces] || []
+        @description = @attributes[:description]
+        @hostname = @attributes[:hostname]
+        @pid = @attributes[:pid]
+        @ha = @attributes[:ha]
+        @type = @attributes[:type]
+        @describe_data = @attributes[:describe_data]
+      end
+
+      # Checks if the container is running.
+      #
+      # @return [Boolean] true if status is "running"
+      def running?
+        status == "running"
+      end
+
+      # Checks if the container is stopped.
+      #
+      # @return [Boolean] true if status is "stopped"
+      def stopped?
+        status == "stopped"
+      end
+
+      # Checks if the container is a template.
+      #
+      # @return [Boolean] true if template flag is 1
+      def template?
+        template == 1
+      end
+
+      # Checks if the container is unprivileged.
+      #
+      # @return [Boolean] true if unprivileged flag is 1
+      def unprivileged?
+        unprivileged == 1
+      end
+    end
+  end
+end

data/lib/pvectl/models/container_operation_result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents the result of a lifecycle operation on a container.
+    #
+    # Extends OperationResult with container-specific attribute.
+    #
+    # @example Successful sync operation
+    #   result = ContainerOperationResult.new(container: ct, task: task, success: task.successful?)
+    #   result.container #=> #<Models::Container>
+    #   result.successful? #=> true
+    #
+    class ContainerOperationResult < OperationResult
+      # @return [Models::Container] The container this result is for
+      attr_reader :container
+
+      # Creates a new ContainerOperationResult.
+      #
+      # @param attrs [Hash] Result attributes including :container
+      def initialize(attrs = {})
+        super
+        @container = @attributes[:container]
+      end
+    end
+  end
+end

data/lib/pvectl/models/dns_config.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents the DNS resolver configuration for a Proxmox node.
+    #
+    # Immutable value object. Created by Repositories::Dns from API data.
+    # Each node has its own DNS settings — there is no cluster-wide DNS config.
+    #
+    # @example Creating from API response
+    #   dns = DnsConfig.new(node: "pve1", search: "example.com",
+    #                       dns1: "8.8.8.8", dns2: "1.1.1.1")
+    #   dns.servers #=> ["8.8.8.8", "1.1.1.1"]
+    #
+    # @see Pvectl::Repositories::Dns Repository that creates DnsConfig instances
+    # @see Pvectl::Presenters::DnsConfig Presenter for formatting DnsConfig data
+    #
+    class DnsConfig < Base
+      # @return [String, nil] node name (not part of the API payload — added by repository)
+      attr_reader :node
+
+      # @return [String, nil] search domain for hostname lookup
+      attr_reader :search
+
+      # @return [String, nil] first nameserver IP address
+      attr_reader :dns1
+
+      # @return [String, nil] second nameserver IP address (optional)
+      attr_reader :dns2
+
+      # @return [String, nil] third nameserver IP address (optional)
+      attr_reader :dns3
+
+      # Creates a new DnsConfig.
+      #
+      # @param attributes [Hash] attribute key-value pairs (node, search, dns1, dns2, dns3)
+      def initialize(attributes = {})
+        super
+        @node = attributes[:node] || attributes["node"]
+        @search = attributes[:search] || attributes["search"]
+        @dns1 = attributes[:dns1] || attributes["dns1"]
+        @dns2 = attributes[:dns2] || attributes["dns2"]
+        @dns3 = attributes[:dns3] || attributes["dns3"]
+      end
+
+      # Returns the configured DNS servers in order, omitting unset entries.
+      #
+      # @return [Array<String>] nameserver IP addresses (may be empty)
+      def servers
+        [dns1, dns2, dns3].compact
+      end
+    end
+  end
+end

data/lib/pvectl/models/hosts_file.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents the contents of /etc/hosts on a Proxmox node.
+    #
+    # Immutable value object. Created by Repositories::Hosts from API data.
+    # /etc/hosts is a per-node raw text file — pvectl does not parse or
+    # validate its contents.
+    #
+    # @example Creating from API response
+    #   hosts = HostsFile.new(node: "pve1",
+    #                         data: "127.0.0.1 localhost\n",
+    #                         digest: "abc123")
+    #
+    # @see Pvectl::Repositories::Hosts Repository that creates HostsFile instances
+    # @see Pvectl::Presenters::HostsFile Presenter for formatting HostsFile data
+    #
+    class HostsFile < Base
+      # @return [String, nil] node name (not part of API payload — added by repository)
+      attr_reader :node
+
+      # @return [String] raw /etc/hosts content (may be empty)
+      attr_reader :data
+
+      # @return [String, nil] digest used for optimistic locking on update
+      attr_reader :digest
+
+      # Creates a new HostsFile.
+      #
+      # @param attributes [Hash] attribute key-value pairs (node, data, digest)
+      def initialize(attributes = {})
+        super
+        @node = attributes[:node] || attributes["node"]
+        @data = attributes[:data] || attributes["data"] || ""
+        @digest = attributes[:digest] || attributes["digest"]
+      end
+
+      # Number of lines in the file (for compact list display).
+      #
+      # @return [Integer] line count
+      def line_count
+        data.lines.count
+      end
+    end
+  end
+end

data/lib/pvectl/models/journal_entry.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a systemd journal line from GET /nodes/{node}/journal.
+    class JournalEntry < Base
+      attr_reader :n, :t
+
+      def initialize(attrs = {})
+        super(attrs)
+        @n = @attributes[:n]
+        @t = @attributes[:t]
+      end
+    end
+  end
+end

data/lib/pvectl/models/network_interface.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a network interface on a Proxmox node.
+    #
+    # Immutable domain model containing network interface attributes and helper
+    # methods for display. Created by Repositories::Node from API data.
+    #
+    # @example Creating a NetworkInterface model
+    #   iface = NetworkInterface.new(iface: "vmbr0", type: "bridge")
+    #   iface.active? #=> true
+    #
+    # @example From API response
+    #   data = { "iface" => "vmbr0", "type" => "bridge", "address" => "192.168.1.10/24" }
+    #   iface = NetworkInterface.new(data)
+    #
+    # @see Pvectl::Repositories::Node Repository that creates NetworkInterface instances
+    #
+    class NetworkInterface < Base
+      # @return [String] interface name (e.g., "vmbr0", "eth0")
+      attr_reader :iface
+
+      # @return [String] interface type (bridge, bond, eth, vlan)
+      attr_reader :type
+
+      # @return [String, nil] IP address with CIDR (e.g., "192.168.1.10/24")
+      attr_reader :address
+
+      # @return [String, nil] gateway IP address
+      attr_reader :gateway
+
+      # @return [Integer] active flag (0/1)
+      attr_reader :active
+
+      # @return [Integer] autostart flag (0/1)
+      attr_reader :autostart
+
+      # @return [String, nil] bridge ports (for bridge type)
+      attr_reader :bridge_ports
+
+      # @return [String, nil] comments
+      attr_reader :comments
+
+      # Creates a new NetworkInterface model from attributes.
+      #
+      # @param attrs [Hash] NetworkInterface attributes from API (string or symbol keys)
+      def initialize(attrs = {})
+        super
+        @iface = attributes[:iface]
+        @type = attributes[:type]
+        @address = attributes[:address]
+        @gateway = attributes[:gateway]
+        @active = attributes[:active]
+        @autostart = attributes[:autostart]
+        @bridge_ports = attributes[:bridge_ports]
+        @comments = attributes[:comments]
+      end
+
+      # Checks if the interface is active.
+      #
+      # @return [Boolean] true if active flag is 1
+      def active?
+        active == 1
+      end
+
+      # Checks if the interface has a gateway configured.
+      #
+      # @return [Boolean] true if gateway is present and non-empty
+      def has_gateway?
+        !gateway.nil? && !gateway.to_s.empty?
+      end
+
+      # Returns IP address without CIDR suffix.
+      #
+      # @return [String, nil] IP address without CIDR, or nil if address is nil
+      # @example
+      #   iface = NetworkInterface.new(address: "192.168.1.10/24")
+      #   iface.ip_without_cidr #=> "192.168.1.10"
+      def ip_without_cidr
+        address&.split("/")&.first
+      end
+    end
+  end
+end

data/lib/pvectl/models/node.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a node in the Proxmox cluster.
+    #
+    # Immutable domain model containing node attributes and domain predicates.
+    # Display formatting is handled by Presenters::Node.
+    # Created by Repositories::Node from API data.
+    #
+    # @example Creating a Node model
+    #   node = Node.new(name: "pve1", status: "online", cpu: 0.23)
+    #   node.online? #=> true
+    #   node.guests_total #=> 42
+    #
+    # @example From API response
+    #   data = { "node" => "pve1", "status" => "online", "cpu" => 0.23 }
+    #   node = Node.new(data)
+    #
+    # @see Pvectl::Repositories::Node Repository that creates Node instances
+    # @see Pvectl::Presenters::Node Presenter for formatting Node data
+    #
+    class Node < Base
+      # @return [String] node name
+      attr_reader :name
+
+      # @return [String] node status (online/offline)
+      attr_reader :status
+
+      # @return [Float, nil] CPU usage (0-1 scale)
+      attr_reader :cpu
+
+      # @return [Integer, nil] total CPU cores
+      attr_reader :maxcpu
+
+      # @return [Integer, nil] memory used in bytes
+      attr_reader :mem
+
+      # @return [Integer, nil] total memory in bytes
+      attr_reader :maxmem
+
+      # @return [Integer, nil] local disk used in bytes
+      attr_reader :disk
+
+      # @return [Integer, nil] total local disk in bytes
+      attr_reader :maxdisk
+
+      # @return [Integer, nil] uptime in seconds
+      attr_reader :uptime
+
+      # @return [String, nil] subscription level (c=community, b=basic, etc.)
+      attr_reader :level
+
+      # @return [String, nil] Proxmox version (e.g., "8.3.2")
+      attr_reader :version
+
+      # @return [String, nil] kernel version (e.g., "6.8.12-1-pve")
+      attr_reader :kernel
+
+      # @return [Array<Float>, nil] load averages [1min, 5min, 15min]
+      attr_reader :loadavg
+
+      # @return [Integer, nil] swap used in bytes
+      attr_reader :swap_used
+
+      # @return [Integer, nil] total swap in bytes
+      attr_reader :swap_total
+
+      # @return [Integer] number of VMs on this node
+      attr_reader :guests_vms
+
+      # @return [Integer] number of containers on this node
+      attr_reader :guests_cts
+
+      # @return [String, nil] node IP address (from interface with gateway)
+      attr_reader :ip
+
+      # Extended attributes for describe command
+      # @return [Hash, nil] CPU info (model, cores, sockets)
+      attr_reader :cpuinfo
+
+      # @return [Hash, nil] boot info (mode: efi/bios)
+      attr_reader :boot_info
+
+      # @return [Hash, nil] root filesystem (used, total, free)
+      attr_reader :rootfs
+
+      # @return [Hash, nil] subscription info (status, level, productname)
+      attr_reader :subscription
+
+      # @return [Hash, nil] DNS configuration (search, dns1, dns2, dns3)
+      attr_reader :dns
+
+      # @return [Hash, nil] time configuration (timezone, localtime, time)
+      attr_reader :time_info
+
+      # @return [Array<Hash>] network interfaces
+      attr_reader :network_interfaces
+
+      # @return [Array<Hash>] system services
+      attr_reader :services
+
+      # @return [Array<Models::Storage>] storage pools
+      attr_reader :storage_pools
+
+      # @return [Array<Hash>] physical disks
+      attr_reader :physical_disks
+
+      # @return [Array<Hash>] QEMU CPU models
+      attr_reader :qemu_cpu_models
+
+      # @return [Array<Hash>] QEMU machine types
+      attr_reader :qemu_machines
+
+      # @return [Integer] number of available updates
+      attr_reader :updates_available
+
+      # @return [Array<Hash>] available updates
+      attr_reader :updates
+
+      # @return [String, nil] offline note message
+      attr_reader :offline_note
+
+      # @return [Hash, nil] firewall configuration data
+      attr_reader :firewall
+
+      # @return [Array] recent task history entries
+      attr_reader :tasks
+
+      # Creates a new Node model from attributes.
+      #
+      # @param attrs [Hash] Node attributes from API (string or symbol keys)
+      def initialize(attrs = {})
+        super(attrs)
+        @name = @attributes[:name] || @attributes[:node]
+        @status = @attributes[:status]
+        @cpu = @attributes[:cpu]
+        @maxcpu = @attributes[:maxcpu]
+        @mem = @attributes[:mem]
+        @maxmem = @attributes[:maxmem]
+        @disk = @attributes[:disk]
+        @maxdisk = @attributes[:maxdisk]
+        @uptime = @attributes[:uptime]
+        @level = @attributes[:level]
+        @version = @attributes[:version]
+        @kernel = @attributes[:kernel]
+        @loadavg = @attributes[:loadavg]
+        @swap_used = @attributes[:swap_used]
+        @swap_total = @attributes[:swap_total]
+        @guests_vms = @attributes[:guests_vms] || 0
+        @guests_cts = @attributes[:guests_cts] || 0
+        @ip = @attributes[:ip]
+        # Extended attributes for describe
+        @cpuinfo = @attributes[:cpuinfo]
+        @boot_info = @attributes[:boot_info]
+        @rootfs = @attributes[:rootfs]
+        @subscription = @attributes[:subscription]
+        @dns = @attributes[:dns]
+        @time_info = @attributes[:time_info]
+        @network_interfaces = @attributes[:network_interfaces] || []
+        @services = @attributes[:services] || []
+        @storage_pools = @attributes[:storage_pools] || []
+        @physical_disks = @attributes[:physical_disks] || []
+        @qemu_cpu_models = @attributes[:qemu_cpu_models] || []
+        @qemu_machines = @attributes[:qemu_machines] || []
+        @updates_available = @attributes[:updates_available] || 0
+        @updates = @attributes[:updates] || []
+        @offline_note = @attributes[:offline_note]
+        @firewall = @attributes[:firewall]
+        @tasks = @attributes[:tasks] || []
+      end
+
+      # Checks if the node is online.
+      #
+      # @return [Boolean] true if status is "online"
+      def online?
+        status == "online"
+      end
+
+      # Checks if the node is offline.
+      #
+      # @return [Boolean] true if status is not "online"
+      def offline?
+        !online?
+      end
+
+      # Returns total guest count (VMs + containers).
+      #
+      # @return [Integer] total guests
+      def guests_total
+        guests_vms + guests_cts
+      end
+    end
+  end
+end

data/lib/pvectl/models/node_operation_result.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents the result of a set/edit operation on a node.
+    #
+    # Extends OperationResult with node-specific attribute.
+    #
+    # @example Successful set operation
+    #   result = NodeOperationResult.new(node_model: node, operation: :set, success: true)
+    #   result.node_model #=> #<Models::Node>
+    #   result.successful? #=> true
+    #
+    class NodeOperationResult < OperationResult
+      # @return [Models::Node, nil] The node this result is for
+      attr_reader :node_model
+
+      # @return [String, nil] optional info message describing the successful
+      #   outcome (e.g., "Wake-on-LAN packet sent (MAC: AA:BB:CC:DD:EE:FF)")
+      attr_reader :info
+
+      # Creates a new NodeOperationResult.
+      #
+      # @param attrs [Hash] Result attributes including :node_model
+      def initialize(attrs = {})
+        super
+        @node_model = @attributes[:node_model]
+        @info = @attributes[:message]
+      end
+
+      # Returns the result message for display.
+      #
+      # On success, prefers the optional `:message` attribute (set by services
+      # that want to surface an outcome detail like a MAC address). Otherwise
+      # falls back to the generic OperationResult logic (error / task / status).
+      #
+      # @return [String]
+      def message
+        return @info if successful? && @info
+
+        super
+      end
+    end
+  end
+end