pvectl 0.2.0

data/lib/pvectl/models/subscription.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a Proxmox subscription record for a specific node.
+    #
+    # Immutable value object created by Repositories::Subscription from the
+    # `/nodes/{node}/subscription` API endpoint. One Subscription per node.
+    #
+    # For community (unlicensed) nodes the API still returns a record with
+    # status="notfound" or similar; key/productname/etc. are nil in that case.
+    #
+    # @see Pvectl::Repositories::Subscription
+    # @see Pvectl::Presenters::Subscription
+    #
+    class Subscription < Base
+      # @return [String, nil] node this subscription belongs to
+      attr_reader :node
+
+      # @return [String, nil] subscription status (active, notfound, invalid, expired, ...)
+      attr_reader :status
+
+      # @return [String, nil] subscription level code (c, b, s, p)
+      attr_reader :level
+
+      # @return [String, nil] human-readable product name
+      attr_reader :productname
+
+      # @return [String, nil] subscription key (full, unmasked)
+      attr_reader :key
+
+      # @return [String, nil] next due date (ISO date string)
+      attr_reader :nextduedate
+
+      # @return [String, nil] registration date (ISO date string)
+      attr_reader :regdate
+
+      # @return [Integer, nil] last server check timestamp (epoch)
+      attr_reader :checktime
+
+      # @return [String, nil] server ID for license validation
+      attr_reader :serverid
+
+      # @return [Integer, nil] number of sockets covered
+      attr_reader :sockets
+
+      # @return [String, nil] URL to web shop
+      attr_reader :url
+
+      # @return [String, nil] signature for offline keys
+      attr_reader :signature
+
+      # @return [String, nil] human-readable status message
+      attr_reader :message
+
+      # Creates a Subscription value object.
+      #
+      # @param attrs [Hash] subscription attributes (symbol or string keys)
+      def initialize(attrs = {})
+        super
+        @node = @attributes[:node]
+        @status = @attributes[:status]
+        @level = @attributes[:level]
+        @productname = @attributes[:productname]
+        @key = @attributes[:key]
+        @nextduedate = @attributes[:nextduedate]
+        @regdate = @attributes[:regdate]
+        @checktime = @attributes[:checktime]
+        @serverid = @attributes[:serverid]
+        @sockets = @attributes[:sockets]
+        @url = @attributes[:url]
+        @signature = @attributes[:signature]
+        @message = @attributes[:message]
+      end
+
+      # @return [Boolean] true if subscription is active
+      def active?
+        status == "active"
+      end
+
+      # @return [Boolean] true if the node has no subscription set
+      def missing?
+        status.nil? || status == "notfound" || status == "new"
+      end
+    end
+  end
+end

data/lib/pvectl/models/syslog_entry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a syslog line from GET /nodes/{node}/syslog.
+    # Proxmox returns syslog entries as {n: line_number, t: text}.
+    class SyslogEntry < Base
+      attr_reader :n, :t
+
+      def initialize(attrs = {})
+        super(attrs)
+        @n = @attributes[:n]
+        @t = @attributes[:t]
+      end
+    end
+  end
+end

data/lib/pvectl/models/task.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a Proxmox task (asynchronous operation).
+    #
+    # Tasks are returned by lifecycle operations (start, stop, etc.).
+    # The UPID (Unique Process ID) identifies the task.
+    #
+    # @example Creating a Task model
+    #   task = Task.new(upid: "UPID:pve1:...", status: "running")
+    #   task.pending? #=> true
+    #   task.completed? #=> false
+    #
+    # @see Pvectl::Repositories::Task Repository that creates Task instances
+    #
+    class Task < Base
+      # @return [String] Unique Process ID
+      attr_reader :upid
+
+      # @return [String] Node where task runs
+      attr_reader :node
+
+      # @return [String] Task type (qmstart, qmstop, etc.)
+      attr_reader :type
+
+      # @return [String] Task status (running, stopped)
+      attr_reader :status
+
+      # @return [String, nil] Exit status (OK, ERROR, etc.)
+      attr_reader :exitstatus
+
+      # @return [Integer, nil] Task start time (Unix timestamp)
+      attr_reader :starttime
+
+      # @return [Integer, nil] Task end time (Unix timestamp)
+      attr_reader :endtime
+
+      # @return [String, nil] User who started the task
+      attr_reader :user
+
+      # Creates a new Task model from attributes.
+      #
+      # @param attrs [Hash] Task attributes from API
+      def initialize(attrs = {})
+        super(attrs)
+        @upid = @attributes[:upid]
+        @node = @attributes[:node]
+        @type = @attributes[:type]
+        @status = @attributes[:status]
+        @exitstatus = @attributes[:exitstatus]
+        @starttime = @attributes[:starttime]
+        @endtime = @attributes[:endtime]
+        @user = @attributes[:user]
+      end
+
+      # Checks if the task is still running.
+      #
+      # @return [Boolean] true if status is "running"
+      def pending?
+        status == "running"
+      end
+
+      # Checks if the task has completed.
+      #
+      # @return [Boolean] true if status is not "running"
+      def completed?
+        !pending?
+      end
+
+      # Checks if the task completed successfully.
+      #
+      # @return [Boolean] true if completed with "OK" exitstatus
+      def successful?
+        completed? && exitstatus == "OK"
+      end
+
+      # Checks if the task failed.
+      #
+      # @return [Boolean] true if completed with non-OK exitstatus
+      def failed?
+        completed? && exitstatus != "OK"
+      end
+
+      # Returns task duration in seconds.
+      #
+      # @return [Integer, nil] duration or nil if not available
+      def duration
+        return nil unless endtime && starttime
+
+        endtime - starttime
+      end
+    end
+  end
+end

data/lib/pvectl/models/task_entry.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents an entry in a node's task list.
+    #
+    # Each entry corresponds to an asynchronous operation (start, stop,
+    # migrate, backup, etc.) performed on a resource. Returned by
+    # GET /nodes/{node}/tasks endpoint.
+    #
+    # @example
+    #   entry = TaskEntry.new(type: "qmstart", status: "stopped", exitstatus: "OK")
+    #   entry.successful? #=> true
+    #
+    class TaskEntry < Base
+      attr_reader :upid, :node, :type, :status, :exitstatus,
+                  :starttime, :endtime, :user, :id, :pid, :pstart
+
+      def initialize(attrs = {})
+        super(attrs)
+        @upid = @attributes[:upid]
+        @node = @attributes[:node]
+        @type = @attributes[:type]
+        @status = @attributes[:status]
+        @exitstatus = @attributes[:exitstatus]
+        @starttime = @attributes[:starttime]
+        @endtime = @attributes[:endtime]
+        @user = @attributes[:user]
+        @id = @attributes[:id]
+        @pid = @attributes[:pid]
+        @pstart = @attributes[:pstart]
+      end
+
+      def successful?
+        completed? && exitstatus == "OK"
+      end
+
+      def failed?
+        completed? && exitstatus != "OK"
+      end
+
+      def completed?
+        status != "running"
+      end
+
+      def duration
+        return nil unless endtime && starttime
+        endtime - starttime
+      end
+    end
+  end
+end

data/lib/pvectl/models/task_log_line.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a single line from a task's log output.
+    # Returned by GET /nodes/{node}/tasks/{upid}/log.
+    class TaskLogLine < Base
+      attr_reader :n, :t
+
+      def initialize(attrs = {})
+        super(attrs)
+        @n = @attributes[:n]
+        @t = @attributes[:t]
+      end
+    end
+  end
+end

data/lib/pvectl/models/time_config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents the time and timezone settings of a Proxmox node.
+    #
+    # Immutable value object holding the response from `GET /nodes/{node}/time`,
+    # augmented with the node name (which is not part of the API payload but is
+    # the identifying context for the lookup).
+    #
+    # Display formatting is handled by Presenters::TimeConfig.
+    #
+    # @example Creating from API data
+    #   data = { time: 1_715_000_000, localtime: 1_715_007_200, timezone: "Europe/Warsaw" }
+    #   model = TimeConfig.new(data.merge(node_name: "pve1"))
+    #   model.timezone #=> "Europe/Warsaw"
+    #
+    # @see Pvectl::Repositories::TimeConfig Repository that creates instances
+    # @see Pvectl::Presenters::TimeConfig Presenter for formatting
+    #
+    class TimeConfig < Base
+      # @return [String, nil] node name (identifies which node this config belongs to)
+      attr_reader :node_name
+
+      # @return [Integer, nil] seconds since epoch (UTC)
+      attr_reader :time
+
+      # @return [Integer, nil] seconds since epoch interpreted as the node's local
+      #   wall clock (Proxmox returns the local clock encoded as if it were UTC).
+      attr_reader :localtime
+
+      # @return [String, nil] IANA timezone name (e.g., "Europe/Warsaw", "UTC")
+      attr_reader :timezone
+
+      # Creates a new TimeConfig.
+      #
+      # @param attributes [Hash] attribute key-value pairs
+      def initialize(attributes = {})
+        super
+        @node_name = @attributes[:node_name]
+        @time = @attributes[:time]
+        @localtime = @attributes[:localtime]
+        @timezone = @attributes[:timezone]
+      end
+    end
+  end
+end

data/lib/pvectl/models/vm.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a QEMU virtual machine in the Proxmox cluster.
+    #
+    # Immutable domain model containing VM attributes and status predicates.
+    # Created by Repositories::Vm from API data.
+    # Display/formatting methods are in Presenters::Vm.
+    #
+    # @example Creating a VM model
+    #   vm = Vm.new(vmid: 100, name: "web", status: "running", node: "pve1")
+    #   vm.running? #=> true
+    #   vm.template? #=> false
+    #
+    # @example From API response
+    #   data = { "vmid" => 100, "name" => "web", "status" => "running" }
+    #   vm = Vm.new(data)
+    #
+    # @see Pvectl::Repositories::Vm Repository that creates VM instances
+    # @see Pvectl::Presenters::Vm Presenter for formatting VM data
+    #
+    class Vm < Base
+      # @return [Integer] unique VM identifier
+      attr_reader :vmid
+
+      # @return [String, nil] VM name
+      attr_reader :name
+
+      # @return [String] VM status (running, stopped, paused)
+      attr_reader :status
+
+      # @return [String] node name where VM runs
+      attr_reader :node
+
+      # @return [Float, nil] current CPU usage (0-1 scale)
+      attr_reader :cpu
+
+      # @return [Integer, nil] maximum CPU cores
+      attr_reader :maxcpu
+
+      # @return [Integer, nil] current memory usage in bytes
+      attr_reader :mem
+
+      # @return [Integer, nil] maximum memory in bytes
+      attr_reader :maxmem
+
+      # @return [Integer, nil] current disk usage in bytes
+      attr_reader :disk
+
+      # @return [Integer, nil] maximum disk size in bytes
+      attr_reader :maxdisk
+
+      # @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] HA state
+      attr_reader :hastate
+
+      # @return [Integer, nil] network input bytes
+      attr_reader :netin
+
+      # @return [Integer, nil] network output bytes
+      attr_reader :netout
+
+      # @return [Hash, nil] raw API responses for describe command
+      attr_reader :describe_data
+
+      # @return [String, nil] resource pool name
+      attr_reader :pool
+
+      # @return [String, nil] resource type from API ("qemu")
+      attr_reader :type
+
+      # Creates a new VM model from attributes.
+      #
+      # @param attrs [Hash] VM 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]
+        @status = @attributes[:status]
+        @node = @attributes[:node]
+        @cpu = @attributes[:cpu]
+        @maxcpu = @attributes[:maxcpu]
+        @mem = @attributes[:mem]
+        @maxmem = @attributes[:maxmem]
+        @disk = @attributes[:disk]
+        @maxdisk = @attributes[:maxdisk]
+        @uptime = @attributes[:uptime]
+        @template = @attributes[:template]
+        @tags = @attributes[:tags]
+        @hastate = @attributes[:hastate]
+        @netin = @attributes[:netin]
+        @netout = @attributes[:netout]
+        @describe_data = @attributes[:describe_data]
+        @pool = @attributes[:pool]
+        @type = @attributes[:type]
+      end
+
+      # Checks if the VM is running.
+      #
+      # @return [Boolean] true if status is "running"
+      def running?
+        status == "running"
+      end
+
+      # Checks if the VM is stopped.
+      #
+      # @return [Boolean] true if status is "stopped"
+      def stopped?
+        status == "stopped"
+      end
+
+      # Checks if the VM is paused.
+      #
+      # @return [Boolean] true if status is "paused"
+      def paused?
+        status == "paused"
+      end
+
+      # Checks if the VM is a template.
+      #
+      # @return [Boolean] true if template flag is 1
+      def template?
+        template == 1
+      end
+    end
+  end
+end

data/lib/pvectl/models/vm_operation_result.rb

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

data/lib/pvectl/models/volume.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents a virtual disk (volume) attached to a VM or container.
+    #
+    # Volumes can originate from two data sources:
+    # - VM/CT config (has name like "scsi0", parsed from config values)
+    # - Storage content API (has volid, content type)
+    #
+    # @example From VM config
+    #   Volume.new(name: "scsi0", storage: "local-lvm", volume_id: "vm-100-disk-0",
+    #              size: "32G", resource_type: "vm", resource_id: 100, node: "pve1")
+    #
+    # @example From storage content API
+    #   Volume.new(volid: "local-lvm:vm-100-disk-0", size: "32G", format: "raw",
+    #              content: "images", resource_type: "vm", resource_id: 100, node: "pve1")
+    #
+    class Volume < Base
+      # @return [String, nil] disk name from config (e.g., "scsi0", "rootfs")
+      attr_reader :name
+
+      # @return [String, nil] storage name (e.g., "local-lvm")
+      attr_reader :storage
+
+      # @return [String, nil] volume identifier within storage (e.g., "vm-100-disk-0")
+      attr_reader :volume_id
+
+      # @return [String, nil] full volume identifier (e.g., "local-lvm:vm-100-disk-0")
+      attr_reader :volid
+
+      # @return [String, nil] volume size (e.g., "32G")
+      attr_reader :size
+
+      # @return [String, nil] disk format (e.g., "raw", "qcow2")
+      attr_reader :format
+
+      # @return [String, nil] resource type ("vm" or "ct")
+      attr_reader :resource_type
+
+      # @return [Integer, nil] VMID or CTID
+      attr_reader :resource_id
+
+      # @return [String, nil] Proxmox node name
+      attr_reader :node
+
+      # @return [String, nil] storage content type (e.g., "images", "rootdir")
+      attr_reader :content
+
+      # @return [String, nil] cache mode (e.g., "writeback", "none")
+      attr_reader :cache
+
+      # @return [String, nil] discard mode (e.g., "on", "ignore")
+      attr_reader :discard
+
+      # @return [Integer, nil] SSD emulation flag (1/0)
+      attr_reader :ssd
+
+      # @return [Integer, nil] IO thread flag (1/0)
+      attr_reader :iothread
+
+      # @return [Integer, nil] backup inclusion flag (1/0)
+      attr_reader :backup
+
+      # @return [String, nil] mount point path (containers only)
+      attr_reader :mp
+
+      # Creates a new Volume instance.
+      #
+      # @param attrs [Hash] volume attributes
+      # @option attrs [String] :name disk name from config
+      # @option attrs [String] :storage storage name
+      # @option attrs [String] :volume_id volume identifier within storage
+      # @option attrs [String] :volid full volume identifier
+      # @option attrs [String] :size volume size
+      # @option attrs [String] :format disk format
+      # @option attrs [String] :resource_type resource type ("vm" or "ct")
+      # @option attrs [Integer] :resource_id VMID or CTID
+      # @option attrs [String] :node Proxmox node name
+      # @option attrs [String] :content storage content type
+      # @option attrs [String] :cache cache mode
+      # @option attrs [String] :discard discard mode
+      # @option attrs [Integer] :ssd SSD emulation flag (1/0)
+      # @option attrs [Integer] :iothread IO thread flag (1/0)
+      # @option attrs [Integer] :backup backup inclusion flag (1/0)
+      # @option attrs [String] :mp mount point path
+      def initialize(attrs = {})
+        super
+        @name = attributes[:name]
+        @storage = attributes[:storage]
+        @volume_id = attributes[:volume_id]
+        @volid = attributes[:volid] || construct_volid
+        @size = attributes[:size]
+        @format = attributes[:format]
+        @resource_type = attributes[:resource_type]
+        @resource_id = attributes[:resource_id]
+        @node = attributes[:node]
+        @content = attributes[:content]
+        @cache = attributes[:cache]
+        @discard = attributes[:discard]
+        @ssd = attributes[:ssd]
+        @iothread = attributes[:iothread]
+        @backup = attributes[:backup]
+        @mp = attributes[:mp]
+      end
+
+      # Checks if volume belongs to a VM.
+      #
+      # @return [Boolean]
+      def vm?
+        resource_type == "vm"
+      end
+
+      # Checks if volume belongs to a container.
+      #
+      # @return [Boolean]
+      def container?
+        resource_type == "ct"
+      end
+
+      private
+
+      # Constructs volid from storage and volume_id when not provided directly.
+      #
+      # @return [String, nil]
+      def construct_volid
+        return nil unless storage && volume_id
+
+        "#{storage}:#{volume_id}"
+      end
+    end
+  end
+end

data/lib/pvectl/models/volume_operation_result.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Models
+    # Represents the result of a set/edit operation on a volume.
+    #
+    # Extends OperationResult with volume-specific attribute.
+    #
+    # @example Successful resize + config update
+    #   result = VolumeOperationResult.new(volume: vol, operation: :set, success: true)
+    #   result.volume #=> #<Models::Volume>
+    #
+    class VolumeOperationResult < OperationResult
+      # @return [Models::Volume, nil] The volume this result is for
+      attr_reader :volume
+
+      # Creates a new VolumeOperationResult.
+      #
+      # @param attrs [Hash] Result attributes including :volume
+      def initialize(attrs = {})
+        super
+        @volume = @attributes[:volume]
+      end
+    end
+  end
+end