pvectl 0.2.0

data/lib/pvectl/services/resize_volume.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates volume resize operations for VMs and containers.
+    #
+    # Handles size parsing, preflight validation (current size comparison),
+    # and execution via the repository interface. Works polymorphically with
+    # both VM and Container repositories (they share #fetch_config and #resize).
+    #
+    # Two-phase operation:
+    # 1. {#preflight} — validates volume exists, computes new size, checks constraints
+    # 2. {#perform} — executes the actual resize via repository
+    #
+    # @example Basic resize flow
+    #   parsed = ResizeVolume.parse_size("+10G")
+    #   service = ResizeVolume.new(repository: vm_repo)
+    #   info = service.preflight(100, "scsi0", parsed, node: "pve1")
+    #   result = service.perform(100, "scsi0", parsed.raw, node: "pve1")
+    #
+    class ResizeVolume
+      # Raised when the specified volume key is not found in resource config.
+      class VolumeNotFoundError < StandardError; end
+
+      # Raised when absolute size is not larger than current disk size.
+      class SizeTooSmallError < StandardError; end
+
+      # Parsed size representation returned by {.parse_size}.
+      #
+      # @!attribute [r] relative
+      #   @return [Boolean] true if size is relative (prefixed with +)
+      # @!attribute [r] value
+      #   @return [String] clean size value without + prefix (e.g., "10G")
+      # @!attribute [r] raw
+      #   @return [String] original size string for API (e.g., "+10G")
+      ParsedSize = Struct.new(:relative, :value, :raw, keyword_init: true) do
+        # Whether this is a relative size (increment).
+        #
+        # @return [Boolean]
+        def relative?
+          relative
+        end
+      end
+
+      # Size regex: optional +, digits with optional decimal, optional T/G/M/K suffix.
+      SIZE_PATTERN = /\A(\+)?(\d+(?:\.\d+)?)([TGMK])?\z/i
+
+      # Multipliers for converting units to megabytes (MB as base unit).
+      UNIT_MULTIPLIERS = {
+        "T" => 1024 * 1024,
+        "G" => 1024,
+        "M" => 1,
+        "K" => 1.0 / 1024
+      }.freeze
+
+      # Parses a size string into a {ParsedSize}.
+      #
+      # Accepts formats like "10G", "+10G", "1.5T", "512M", "+100".
+      # Suffix is uppercased. No suffix means raw number.
+      #
+      # @param size_str [String] size string to parse
+      # @return [ParsedSize] parsed size components
+      # @raise [ArgumentError] if format is invalid, empty, or negative
+      #
+      # @example Relative size
+      #   ResizeVolume.parse_size("+10G")
+      #   #=> ParsedSize(relative: true, value: "10G", raw: "+10G")
+      #
+      # @example Absolute size
+      #   ResizeVolume.parse_size("50G")
+      #   #=> ParsedSize(relative: false, value: "50G", raw: "50G")
+      def self.parse_size(size_str)
+        raise ArgumentError, "Size cannot be empty" if size_str.nil? || size_str.strip.empty?
+
+        match = SIZE_PATTERN.match(size_str.strip)
+        raise ArgumentError, "Invalid size format: #{size_str}" unless match
+
+        plus, number, suffix = match.captures
+        suffix = suffix&.upcase
+
+        raise ArgumentError, "Size must be positive: #{size_str}" if number.to_f <= 0
+
+        clean_value = "#{number}#{suffix}"
+        raw_value = "#{plus}#{number}#{suffix}"
+
+        ParsedSize.new(
+          relative: !plus.nil?,
+          value: clean_value,
+          raw: raw_value
+        )
+      end
+
+      # Creates a new ResizeVolume service.
+      #
+      # @param repository [Repositories::Vm, Repositories::Container] resource repository
+      def initialize(repository:)
+        @repository = repository
+      end
+
+      # Validates the resize operation and returns size information.
+      #
+      # Checks that the disk exists in the resource config, extracts current
+      # size, calculates new size, and validates constraints (absolute must
+      # be larger than current).
+      #
+      # @param id [Integer] resource identifier (VMID or CTID)
+      # @param disk [String] disk key (e.g., "scsi0", "rootfs", "mp0")
+      # @param parsed_size [ParsedSize] parsed size from {.parse_size}
+      # @param node [String] node name
+      # @return [Hash] preflight info with :disk, :current_size, :new_size
+      # @raise [VolumeNotFoundError] if volume not in config or size not extractable
+      # @raise [SizeTooSmallError] if absolute size <= current size
+      def preflight(id, disk, parsed_size, node:)
+        config = @repository.fetch_config(node, id)
+        current_size = extract_disk_size(config, disk, id)
+        new_size = calculate_new_size(current_size, parsed_size)
+        validate_new_size!(current_size, new_size, parsed_size)
+
+        { disk: disk, current_size: current_size, new_size: new_size }
+      end
+
+      # Executes the disk resize via repository.
+      #
+      # @param id [Integer] resource identifier (VMID or CTID)
+      # @param disk [String] disk key
+      # @param raw_size [String] size string for API (e.g., "+10G", "50G")
+      # @param node [String] node name
+      # @return [Models::OperationResult] operation result
+      def perform(id, disk, raw_size, node:)
+        @repository.resize(id, node, disk: disk, size: raw_size)
+        Models::OperationResult.new(
+          operation: :resize_volume,
+          success: true,
+          resource: { id: id, node: node, disk: disk, size: raw_size }
+        )
+      rescue StandardError => e
+        Models::OperationResult.new(
+          operation: :resize_volume,
+          success: false,
+          error: e.message,
+          resource: { id: id, node: node, disk: disk }
+        )
+      end
+
+      private
+
+      # Extracts the disk size from a config value string.
+      #
+      # Config values have formats like:
+      # - VM:        "local-lvm:vm-100-disk-0,size=32G"
+      # - Container: "local-lvm:subvol-100-disk-0,size=8G"
+      # - Rootfs:    "local-lvm:subvol-100-disk-0,size=8G"
+      #
+      # @param config [Hash] resource configuration
+      # @param disk [String] disk key to look up
+      # @param id [Integer] resource ID (for error messages)
+      # @return [String] current size (e.g., "32G")
+      # @raise [VolumeNotFoundError] if volume not found or size not extractable
+      def extract_disk_size(config, disk, id)
+        disk_value = config[disk.to_sym]
+        raise VolumeNotFoundError, "Volume '#{disk}' not found in config for resource #{id}" unless disk_value
+
+        size_match = disk_value.to_s.match(/size=(\d+(?:\.\d+)?[TGMK]?)/i)
+        raise VolumeNotFoundError, "Cannot determine size for volume '#{disk}' on resource #{id}" unless size_match
+
+        size_match[1]
+      end
+
+      # Calculates the new size after resize.
+      #
+      # For relative sizes, adds the increment to current size (converting
+      # units as needed). For absolute sizes, returns the parsed value directly.
+      #
+      # @param current_size [String] current size (e.g., "32G")
+      # @param parsed_size [ParsedSize] parsed size
+      # @return [String] new size (e.g., "42G")
+      def calculate_new_size(current_size, parsed_size)
+        if parsed_size.relative?
+          current_num, current_suffix = parse_size_components(current_size)
+          add_num, add_suffix = parse_size_components(parsed_size.value)
+
+          converted_add = convert_to_unit(add_num, add_suffix, current_suffix)
+          new_num = current_num + converted_add
+
+          format_size(new_num, current_suffix)
+        else
+          parsed_size.value
+        end
+      end
+
+      # Validates that the new size is larger than current for absolute resizes.
+      #
+      # Relative sizes always pass (Proxmox enforces positive increments).
+      # Absolute sizes must be strictly larger than current.
+      #
+      # @param current_size [String] current size
+      # @param new_size [String] new size
+      # @param parsed_size [ParsedSize] parsed size (to check if relative)
+      # @raise [SizeTooSmallError] if absolute size <= current
+      def validate_new_size!(current_size, new_size, parsed_size)
+        return if parsed_size.relative?
+
+        if size_to_bytes(new_size) <= size_to_bytes(current_size)
+          raise SizeTooSmallError,
+                "New size #{new_size} must be larger than current size #{current_size}"
+        end
+      end
+
+      # Parses size string into numeric value and unit suffix.
+      #
+      # @param size [String] size string (e.g., "32G", "1.5T", "100")
+      # @return [Array(Float, String)] number and suffix (defaults to "G")
+      def parse_size_components(size)
+        match = size.to_s.match(/\A(\d+(?:\.\d+)?)([TGMK])?\z/i)
+        return [0.0, "G"] unless match
+
+        [match[1].to_f, (match[2] || "G").upcase]
+      end
+
+      # Converts a value from one unit to another using MB as base.
+      #
+      # @param value [Float] numeric value
+      # @param from_unit [String] source unit (T, G, M, K)
+      # @param to_unit [String] target unit (T, G, M, K)
+      # @return [Float] converted value
+      def convert_to_unit(value, from_unit, to_unit)
+        mb_value = value * UNIT_MULTIPLIERS.fetch(from_unit, 1024)
+        mb_value / UNIT_MULTIPLIERS.fetch(to_unit, 1024)
+      end
+
+      # Formats a numeric value and suffix into a size string.
+      #
+      # Produces integer format when possible (e.g., "42G" not "42.0G").
+      #
+      # @param value [Float] numeric value
+      # @param suffix [String] unit suffix
+      # @return [String] formatted size (e.g., "42G")
+      def format_size(value, suffix)
+        formatted = value == value.to_i ? value.to_i.to_s : format("%.1f", value)
+        "#{formatted}#{suffix}"
+      end
+
+      # Converts a size string to bytes for comparison.
+      #
+      # @param size [String] size string (e.g., "32G")
+      # @return [Float] size in bytes
+      def size_to_bytes(size)
+        num, suffix = parse_size_components(size)
+        num * UNIT_MULTIPLIERS.fetch(suffix, 1024) * 1024 * 1024 # MB to bytes
+      end
+    end
+  end
+end

data/lib/pvectl/services/resource_delete.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates deletion of VMs and containers.
+    #
+    # Handles validation, force-stop of running resources, and async/sync modes.
+    #
+    # @example Delete stopped VMs
+    #   service = ResourceDelete.new(vm_repository: vm_repo, container_repository: ct_repo, task_repository: task_repo)
+    #   results = service.execute(:vm, [vm1, vm2])
+    #
+    # @example Delete with force (stops running VMs first)
+    #   service = ResourceDelete.new(..., options: { force: true })
+    #   results = service.execute(:vm, [running_vm])
+    #
+    class ResourceDelete
+      DEFAULT_TIMEOUT = 60
+
+      # Creates a new ResourceDelete service.
+      #
+      # @param vm_repository [Repositories::Vm] VM repository
+      # @param container_repository [Repositories::Container] Container repository
+      # @param task_repository [Repositories::Task] Task repository
+      # @param options [Hash] Options (force, keep_disks, purge, timeout, async, fail_fast)
+      def initialize(vm_repository:, container_repository:, task_repository:, options: {})
+        @vm_repository = vm_repository
+        @container_repository = container_repository
+        @task_repository = task_repository
+        @options = options
+      end
+
+      # Executes delete operation on resources.
+      #
+      # @param resource_type [Symbol] :vm or :container
+      # @param resources [Array<Models::Vm, Models::Container>] Resources to delete
+      # @return [Array<Models::OperationResult>] Results for each resource
+      def execute(resource_type, resources)
+        @resource_type = resource_type
+        results = []
+
+        resources.each do |resource|
+          result = delete_single(resource)
+          results << result
+
+          break if @options[:fail_fast] && result.failed?
+        end
+
+        results
+      end
+
+      private
+
+      # Deletes a single resource.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource to delete
+      # @return [Models::OperationResult] Result
+      def delete_single(resource)
+        # Check if running
+        if resource.status == "running"
+          return running_error(resource) unless @options[:force]
+
+          stop_result = stop_resource(resource)
+          return stop_result if stop_result.failed?
+        end
+
+        # Perform delete
+        perform_delete(resource)
+      rescue StandardError => e
+        build_result(resource,
+          operation: :delete,
+          success: false,
+          error: e.message
+        )
+      end
+
+      # Returns error for running resource.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource
+      # @return [Models::OperationResult] Failed result
+      def running_error(resource)
+        type_name = @resource_type == :vm ? "VM" : "Container"
+        build_result(resource,
+          operation: :delete,
+          success: false,
+          error: "#{type_name} #{resource.vmid} is running. Stop it first or use --force"
+        )
+      end
+
+      # Stops a running resource.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource
+      # @return [Models::OperationResult] Result
+      def stop_resource(resource)
+        repo = repository_for(@resource_type)
+        upid = repo.stop(resource.vmid, resource.node)
+        task = @task_repository.wait(upid, timeout: timeout)
+
+        if task.successful?
+          build_result(resource, operation: :stop, task: task, success: true)
+        else
+          build_result(resource,
+            operation: :delete,
+            success: false,
+            error: "Failed to stop: #{task.exitstatus}"
+          )
+        end
+      end
+
+      # Performs the actual delete operation.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource
+      # @return [Models::OperationResult] Result
+      def perform_delete(resource)
+        repo = repository_for(@resource_type)
+        delete_opts = {
+          destroy_disks: !@options[:keep_disks],
+          purge: @options[:purge] || false,
+          force: false
+        }
+
+        upid = repo.delete(resource.vmid, resource.node, **delete_opts)
+
+        if @options[:async]
+          build_result(resource,
+            operation: :delete,
+            task_upid: upid,
+            success: :pending
+          )
+        else
+          task = @task_repository.wait(upid, timeout: timeout)
+          build_result(resource,
+            operation: :delete,
+            task: task,
+            success: task.successful?
+          )
+        end
+      end
+
+      # Builds typed OperationResult for the current resource type.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource
+      # @param attrs [Hash] Result attributes
+      # @return [Models::VmOperationResult, Models::ContainerOperationResult] Typed result
+      def build_result(resource, **attrs)
+        if @resource_type == :vm
+          Models::VmOperationResult.new(vm: resource, **attrs)
+        else
+          Models::ContainerOperationResult.new(container: resource, **attrs)
+        end
+      end
+
+      # Returns the appropriate repository for resource type.
+      #
+      # @param type [Symbol] :vm or :container
+      # @return [Repositories::Vm, Repositories::Container] Repository
+      def repository_for(type)
+        type == :vm ? @vm_repository : @container_repository
+      end
+
+      # Returns configured timeout.
+      #
+      # @return [Integer] Timeout in seconds
+      def timeout
+        @options[:timeout] || DEFAULT_TIMEOUT
+      end
+    end
+  end
+end

data/lib/pvectl/services/resource_migration.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates migration of VMs and containers between cluster nodes.
+    #
+    # Single service for both resource types, parameterized by resource_type.
+    # Async mode (default): returns UPID immediately, no blocking.
+    # Sync mode (--wait): polls Task until completion or timeout.
+    #
+    # @example Migrate VMs async (default)
+    #   service = ResourceMigration.new(vm_repository: vm_repo, container_repository: ct_repo, task_repository: task_repo)
+    #   results = service.execute(:vm, [vm1, vm2], target: "pve2")
+    #
+    # @example Migrate with sync wait
+    #   service = ResourceMigration.new(..., options: { wait: true })
+    #   results = service.execute(:vm, [vm], target: "pve2")
+    #
+    class ResourceMigration
+      DEFAULT_TIMEOUT = 600
+
+      # Creates a new ResourceMigration service.
+      #
+      # @param vm_repository [Repositories::Vm] VM repository
+      # @param container_repository [Repositories::Container] Container repository
+      # @param task_repository [Repositories::Task] Task repository
+      # @param options [Hash] Options (online, restart, target_storage, timeout, wait, fail_fast)
+      def initialize(vm_repository:, container_repository:, task_repository:, options: {})
+        @vm_repository = vm_repository
+        @container_repository = container_repository
+        @task_repository = task_repository
+        @options = options
+      end
+
+      # Executes migration operation on resources.
+      #
+      # @param resource_type [Symbol] :vm or :container
+      # @param resources [Array<Models::Vm, Models::Container>] Resources to migrate
+      # @param target [String] Target node name
+      # @return [Array<Models::OperationResult>] Results for each resource
+      def execute(resource_type, resources, target:)
+        @resource_type = resource_type
+
+        migratable, skipped = partition_by_target(resources, target)
+        report_skipped(skipped, target)
+        return all_on_target_results(target) if migratable.empty?
+
+        results = []
+        migratable.each do |resource|
+          result = migrate_single(resource, target)
+          results << result
+
+          break if @options[:fail_fast] && result.failed?
+        end
+
+        results
+      end
+
+      private
+
+      # Partitions resources into migratable and already-on-target groups.
+      #
+      # @param resources [Array] Resources to partition
+      # @param target [String] Target node name
+      # @return [Array<Array, Array>] [migratable, skipped]
+      def partition_by_target(resources, target)
+        resources.partition { |r| r.node != target }
+      end
+
+      # Reports skipped resources to stderr.
+      #
+      # @param skipped [Array] Resources already on target
+      # @param target [String] Target node name
+      # @return [void]
+      def report_skipped(skipped, target)
+        type_name = @resource_type == :vm ? "VM" : "container"
+        skipped.each do |r|
+          $stderr.puts "Skipping #{type_name} #{r.vmid} (already on #{target})"
+        end
+      end
+
+      # Handles case when all resources are already on target.
+      #
+      # @param target [String] Target node name
+      # @return [Array] Empty results array
+      def all_on_target_results(target)
+        $stderr.puts "All resources are already on target node #{target}"
+        []
+      end
+
+      # Migrates a single resource.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource to migrate
+      # @param target [String] Target node name
+      # @return [Models::OperationResult] Result
+      def migrate_single(resource, target)
+        repo = repository_for(@resource_type)
+        params = build_migrate_params(target)
+        upid = repo.migrate(resource.vmid, resource.node, params)
+
+        if @options[:wait]
+          task = @task_repository.wait(upid, timeout: timeout)
+          build_result(resource,
+            operation: :migrate,
+            task: task,
+            success: task.successful?
+          )
+        else
+          build_result(resource,
+            operation: :migrate,
+            task_upid: upid,
+            success: :pending
+          )
+        end
+      rescue StandardError => e
+        build_result(resource,
+          operation: :migrate,
+          success: false,
+          error: e.message
+        )
+      end
+
+      # Builds migration parameters for the API call.
+      #
+      # @param target [String] Target node name
+      # @return [Hash] Migration parameters
+      def build_migrate_params(target)
+        params = { target: target }
+
+        if @options[:online]
+          params[:online] = 1
+          params[:"with-local-disks"] = 1 if @resource_type == :vm
+        end
+
+        params[:restart] = 1 if @options[:restart] && @resource_type == :container
+        params[:targetstorage] = @options[:target_storage] if @options[:target_storage]
+
+        params
+      end
+
+      # Builds typed OperationResult for the current resource type.
+      #
+      # @param resource [Models::Vm, Models::Container] Resource
+      # @param attrs [Hash] Result attributes
+      # @return [Models::VmOperationResult, Models::ContainerOperationResult] Typed result
+      def build_result(resource, **attrs)
+        if @resource_type == :vm
+          Models::VmOperationResult.new(vm: resource, **attrs)
+        else
+          Models::ContainerOperationResult.new(container: resource, **attrs)
+        end
+      end
+
+      # Returns the appropriate repository for resource type.
+      #
+      # @param type [Symbol] :vm or :container
+      # @return [Repositories::Vm, Repositories::Container] Repository
+      def repository_for(type)
+        type == :vm ? @vm_repository : @container_repository
+      end
+
+      # Returns configured timeout.
+      #
+      # @return [Integer] Timeout in seconds
+      def timeout
+        @options[:timeout] || DEFAULT_TIMEOUT
+      end
+    end
+  end
+end

data/lib/pvectl/services/sendkey.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates QEMU monitor key-send operations for a single VM.
+    #
+    # Resolves the VM (and its node) via the repository, validates that the
+    # target VM is running, and forwards the key sequence verbatim to the
+    # Proxmox API. The key string is passed through unmodified — interpretation
+    # is delegated to QEMU's qcode parser.
+    #
+    # @example Sending Ctrl+Alt+Delete to a running VM
+    #   service = Sendkey.new(vm_repository: vm_repo)
+    #   result = service.execute(vmid: 100, key: "ctrl-alt-delete")
+    #   result.successful? #=> true
+    #
+    class Sendkey
+      # Creates a new Sendkey service.
+      #
+      # @param vm_repository [Repositories::Vm] VM repository for lookup and key send
+      def initialize(vm_repository:)
+        @vm_repository = vm_repository
+      end
+
+      # Sends a QEMU key sequence to a VM.
+      #
+      # Looks up the VM (the +node+ kwarg is honored when provided, otherwise
+      # the node is taken from the resolved VM). Returns a failed
+      # +VmOperationResult+ when the VM cannot be found, is not running, or
+      # the underlying API call raises.
+      #
+      # @param vmid [Integer, String] VM identifier
+      # @param key [String] QEMU qcode key sequence (e.g., "ctrl-alt-delete")
+      # @param node [String, nil] optional node override
+      # @return [Models::VmOperationResult] result of the operation
+      def execute(vmid:, key:, node: nil)
+        vmid_int = vmid.to_i
+
+        vm = @vm_repository.get(vmid_int)
+        return not_found_result(vmid_int) unless vm
+
+        target_node = node || vm.node
+        return not_running_result(vm, target_node, key) unless vm.status == "running"
+
+        @vm_repository.sendkey(vmid_int, target_node, key)
+
+        success_result(vm, target_node, key)
+      rescue StandardError => e
+        failure_result(vm, target_node || vm&.node, key, e.message)
+      end
+
+      private
+
+      # @param vmid [Integer]
+      # @return [Models::VmOperationResult]
+      def not_found_result(vmid)
+        Models::VmOperationResult.new(
+          operation: :sendkey,
+          success: false,
+          error: "VM #{vmid} not found",
+          resource: { vmid: vmid }
+        )
+      end
+
+      # @param vm [Models::Vm]
+      # @param node [String]
+      # @param key [String]
+      # @return [Models::VmOperationResult]
+      def not_running_result(vm, node, key)
+        Models::VmOperationResult.new(
+          vm: vm,
+          operation: :sendkey,
+          success: false,
+          error: "VM #{vm.vmid} is not running (status: #{vm.status})",
+          resource: { vmid: vm.vmid, node: node, key: key }
+        )
+      end
+
+      # @param vm [Models::Vm]
+      # @param node [String]
+      # @param key [String]
+      # @return [Models::VmOperationResult]
+      def success_result(vm, node, key)
+        Models::VmOperationResult.new(
+          vm: vm,
+          operation: :sendkey,
+          success: true,
+          resource: { vmid: vm.vmid, node: node, key: key }
+        )
+      end
+
+      # @param vm [Models::Vm, nil]
+      # @param node [String, nil]
+      # @param key [String]
+      # @param message [String]
+      # @return [Models::VmOperationResult]
+      def failure_result(vm, node, key, message)
+        Models::VmOperationResult.new(
+          vm: vm,
+          operation: :sendkey,
+          success: false,
+          error: message,
+          resource: { vmid: vm&.vmid, node: node, key: key }
+        )
+      end
+    end
+  end
+end