pvectl 0.2.0

data/lib/pvectl/commands/migrate_vm.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl migrate vm` command.
+    #
+    # Migrates one or more virtual machines to another cluster node.
+    # Always requires --target and confirmation (--yes to skip).
+    #
+    # @example Migrate a single VM
+    #   pvectl migrate vm 100 --target pve2 --yes
+    #
+    # @example Online migration
+    #   pvectl migrate vm 100 --target pve2 --online --yes
+    #
+    class MigrateVm
+      include MigrateCommand
+
+      # Registers the migrate command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Migrate a resource to another node"
+        cli.long_desc <<~HELP
+          Migrate virtual machines or containers between cluster nodes.
+          Supports live migration (--online) for zero-downtime moves.
+
+          EXAMPLES
+            Offline migration:
+              $ pvectl migrate vm 100 --target pve2
+
+            Live migration (zero downtime):
+              $ pvectl migrate vm 100 --target pve2 --online
+
+            Migrate a container with restart:
+              $ pvectl migrate ct 200 --target pve2 --restart
+
+            Migrate to different storage:
+              $ pvectl migrate vm 100 --target pve2 --target-storage local-lvm
+
+            Batch migrate all VMs from a node:
+              $ pvectl migrate vm --all --node pve1 --target pve2 --yes
+
+            Migrate VMs matching a selector:
+              $ pvectl migrate vm --all -l tags=web --target pve2 --yes
+
+          NOTES
+            --online (live migration) requires shared storage or migration
+            network configured between nodes.
+
+            Container migration with --restart briefly stops the container,
+            migrates, then starts it on the target node.
+
+            --target is required for all migrations.
+
+            Default timeout is 600 seconds. Use --timeout to adjust for
+            large VMs with lots of memory/disk.
+
+          SEE ALSO
+            pvectl help clone           Clone instead of move
+            pvectl help get nodes       List available target nodes
+        HELP
+        cli.arg_name "RESOURCE_TYPE [ID...]"
+        cli.command :migrate do |c|
+          c.desc "Target node (required)"
+          c.flag [:target, :t], arg_name: "NODE"
+
+          c.desc "Online/live migration"
+          c.switch [:online], negatable: false
+
+          c.desc "Restart migration (container only)"
+          c.switch [:restart], negatable: false
+
+          c.desc "Target storage mapping"
+          c.flag [:"target-storage"], arg_name: "STORAGE"
+
+          c.desc "Select all resources of this type"
+          c.switch [:all, :A], negatable: false
+
+          c.desc "Filter by source node"
+          c.flag [:node, :n], arg_name: "NODE"
+
+          c.desc "Filter by selector (e.g., status=running,tags=prod)"
+          c.flag [:l, :selector], arg_name: "SELECTOR", multiple: true
+
+          c.desc "Skip confirmation prompt"
+          c.switch [:yes, :y], negatable: false
+
+          c.desc "Stop on first error"
+          c.switch [:"fail-fast"], negatable: false
+
+          c.desc "Wait for migration to complete (sync mode)"
+          c.switch [:wait], negatable: false
+
+          c.desc "Timeout in seconds for sync operations (default: 600)"
+          c.flag [:timeout], type: Integer, arg_name: "SECONDS"
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+
+            exit_code = case resource_type
+            when "vm"
+              Commands::MigrateVm.execute(args, options, global_options)
+            when "container", "ct"
+              Commands::MigrateContainer.execute(args, options, global_options)
+            else
+              $stderr.puts "Error: Unknown resource type: #{resource_type}"
+              $stderr.puts "Valid types: vm, container, ct"
+              ExitCodes::USAGE_ERROR
+            end
+
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      RESOURCE_TYPE = :vm
+      SUPPORTED_RESOURCES = %w[vm].freeze
+    end
+  end
+end

data/lib/pvectl/commands/move_disk_command.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for the move disk commands (move disk vm, move disk ct).
+    #
+    # Mirrors the structure of MigrateCommand but operates on a single resource
+    # (VM or container) and a single disk/volume rather than a batch.
+    #
+    # @example Including in a command class
+    #   class MoveDiskVm
+    #     include MoveDiskCommand
+    #     RESOURCE_TYPE = :vm
+    #     SUPPORTED_RESOURCES = %w[vm].freeze
+    #   end
+    #
+    module MoveDiskCommand
+      # Allowed target formats for VM disks (per Proxmox API).
+      VALID_FORMATS = %w[raw qcow2 vmdk].freeze
+
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the move disk command.
+        #
+        # @param args [Array<String>] command-positional args ([id, disk])
+        # @param options [Hash] command options
+        # @param global_options [Hash] global CLI options
+        # @return [Integer] exit code
+        def execute(args, options, global_options)
+          new(args, options, global_options).execute
+        end
+      end
+
+      # Hook called when the module is included.
+      #
+      # @param base [Class] the class including this module
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Initializes a move disk command.
+      #
+      # @param args [Array<String>] command-positional args ([id, disk])
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(args, options, global_options)
+        @args = Array(args).compact
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the move disk command.
+      #
+      # @return [Integer] exit code
+      def execute
+        target = @options[:target]
+        return usage_error("--target is required") if target.nil? || target.to_s.empty?
+
+        return usage_error("#{id_label} and #{disk_label} are required") if @args.size < 2
+
+        id_str, disk = @args[0], @args[1]
+
+        unless id_str.to_s.match?(/\A\d+\z/)
+          return usage_error("Invalid #{id_label}: #{id_str}")
+        end
+
+        if @options[:format]
+          return usage_error("--format is not supported for containers") if resource_type_symbol == :container
+          return usage_error("Invalid format: #{@options[:format]} (allowed: #{VALID_FORMATS.join(', ')})") unless VALID_FORMATS.include?(@options[:format])
+        end
+
+        perform_operation(id_str.to_i, disk, target)
+      end
+
+      private
+
+      # Returns the resource type symbol (:vm or :container).
+      #
+      # @return [Symbol]
+      def resource_type_symbol
+        self.class::RESOURCE_TYPE
+      end
+
+      # Returns the human label for the resource ID ("VMID" or "CTID").
+      #
+      # @return [String]
+      def id_label
+        resource_type_symbol == :vm ? "VMID" : "CTID"
+      end
+
+      # Returns the human label for the disk/volume.
+      #
+      # @return [String]
+      def disk_label
+        resource_type_symbol == :vm ? "DISK" : "VOLUME"
+      end
+
+      # Performs the move operation: loads config, resolves resource, prompts,
+      # invokes service, prints result.
+      #
+      # @param id [Integer] resource identifier
+      # @param disk [String] disk/volume key
+      # @param target [String] target storage
+      # @return [Integer] exit code
+      def perform_operation(id, disk, target)
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        resource = resolve_resource(connection, id)
+        return resource_not_found(id) if resource.nil?
+
+        return ExitCodes::SUCCESS unless confirm_operation(resource, disk, target)
+
+        service = build_service(connection)
+        result = service.execute(resource_type_symbol, resource,
+                                 disk: disk, target_storage: target)
+
+        output_result(result)
+        result.failed? ? ExitCodes::GENERAL_ERROR : ExitCodes::SUCCESS
+      rescue Pvectl::Config::ConfigNotFoundError,
+             Pvectl::Config::InvalidConfigError,
+             Pvectl::Config::ContextNotFoundError,
+             Pvectl::Config::ClusterNotFoundError,
+             Pvectl::Config::UserNotFoundError
+        raise
+      rescue StandardError => e
+        $stderr.puts "Error: #{e.message}"
+        ExitCodes::GENERAL_ERROR
+      end
+
+      # Resolves the single resource by ID using the appropriate repository.
+      #
+      # @param connection [Connection] API connection
+      # @param id [Integer] resource ID
+      # @return [Models::Vm, Models::Container, nil]
+      def resolve_resource(connection, id)
+        repo = resource_type_symbol == :vm ?
+          Pvectl::Repositories::Vm.new(connection) :
+          Pvectl::Repositories::Container.new(connection)
+        repo.get(id)
+      end
+
+      # Builds the MoveDisk service with required dependencies.
+      #
+      # @param connection [Connection] API connection
+      # @return [Services::MoveDisk]
+      def build_service(connection)
+        Pvectl::Services::MoveDisk.new(
+          vm_repository: Pvectl::Repositories::Vm.new(connection),
+          container_repository: Pvectl::Repositories::Container.new(connection),
+          task_repository: Pvectl::Repositories::Task.new(connection),
+          options: service_options
+        )
+      end
+
+      # Builds service options from command options.
+      #
+      # @return [Hash]
+      def service_options
+        opts = {}
+        opts[:format] = @options[:format] if @options[:format]
+        opts[:delete_source] = true if @options[:"delete-source"]
+        opts[:bandwidth] = @options[:bandwidth].to_i if @options[:bandwidth]
+        opts[:wait] = true if @options[:wait]
+        opts[:timeout] = @options[:timeout] if @options[:timeout]
+        opts
+      end
+
+      # Confirms the move operation with the user.
+      #
+      # @param resource [Models::Vm, Models::Container]
+      # @param disk [String]
+      # @param target [String]
+      # @return [Boolean] true if the operation should proceed
+      def confirm_operation(resource, disk, target)
+        return true if @options[:yes]
+
+        type_name = resource_type_symbol == :vm ? "VM" : "container"
+        $stdout.puts "You are about to move #{disk} of #{type_name} #{resource.vmid} " \
+                     "(#{resource.name || 'unnamed'}) on #{resource.node} to storage #{target}."
+        $stdout.puts ""
+        if @options[:"delete-source"]
+          $stdout.puts "Source disk WILL be deleted after a successful copy."
+        else
+          $stdout.puts "Source disk will be kept as an unused entry."
+        end
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      end
+
+      # Loads configuration from file or environment.
+      #
+      # @return [void]
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: @global_options[:config])
+        @config = service.current_config
+      end
+
+      # Outputs the operation result using the configured formatter.
+      #
+      # @param result [Models::OperationResult]
+      # @return [void]
+      def output_result(result)
+        presenter = if resource_type_symbol == :vm
+                      Pvectl::Presenters::VmOperationResult.new
+                    else
+                      Pvectl::Presenters::ContainerOperationResult.new
+                    end
+        format = @global_options[:output] || "table"
+        color_flag = @global_options[:color]
+
+        formatter = Pvectl::Formatters::Registry.for(format)
+        output = formatter.format([result], presenter, color: color_flag)
+        puts output
+      end
+
+      # Outputs usage error and returns the usage exit code.
+      #
+      # @param message [String]
+      # @return [Integer]
+      def usage_error(message)
+        $stderr.puts "Error: #{message}"
+        ExitCodes::USAGE_ERROR
+      end
+
+      # Outputs "not found" error and returns the not-found exit code.
+      #
+      # @param id [Integer]
+      # @return [Integer]
+      def resource_not_found(id)
+        $stderr.puts "Error: No #{resource_type_symbol == :vm ? 'VM' : 'container'} found with ID #{id}"
+        ExitCodes::NOT_FOUND
+      end
+    end
+  end
+end

data/lib/pvectl/commands/move_disk_container.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl move disk ct` command.
+    #
+    # Moves a container volume (rootfs / mpN) to a different storage on the
+    # same node. The --format flag is rejected because the LXC move_volume
+    # API does not accept a format.
+    #
+    # @example Move rootfs of container 200 to storage2
+    #   pvectl move disk ct 200 rootfs --target storage2
+    #
+    class MoveDiskContainer
+      include MoveDiskCommand
+
+      RESOURCE_TYPE = :container
+      SUPPORTED_RESOURCES = %w[container ct].freeze
+    end
+  end
+end

data/lib/pvectl/commands/move_disk_vm.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl move disk vm` command.
+    #
+    # Moves a VM disk to a different storage on the same node.
+    # The Proxmox API call is asynchronous — the returned UPID is included
+    # in the OperationResult. Use --wait to block until the task completes.
+    #
+    # @example Move scsi0 of VM 100 to storage2
+    #   pvectl move disk vm 100 scsi0 --target storage2
+    #
+    # @example Move and convert format, deleting source after copy
+    #   pvectl move disk vm 100 scsi0 --target storage2 --format qcow2 --delete-source
+    #
+    class MoveDiskVm
+      include MoveDiskCommand
+
+      # Registers the move command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Move a VM disk or container volume to another storage"
+        cli.long_desc <<~HELP
+          Move a VM disk or container volume to a different storage on the
+          same node. The source disk is kept as an unused entry by default;
+          pass --delete-source to remove it after a successful copy.
+
+          The operation is asynchronous: the returned task UPID can be
+          tracked with `pvectl get tasks` or `pvectl logs task <upid>`.
+          Pass --wait to block until the move completes (with --timeout).
+
+          EXAMPLES
+            Move VM disk to another storage:
+              $ pvectl move disk vm 100 scsi0 --target storage2
+
+            Move VM disk and convert format:
+              $ pvectl move disk vm 100 scsi0 --target storage2 --format qcow2
+
+            Move VM disk and delete source after copy:
+              $ pvectl move disk vm 100 scsi0 --target storage2 --delete-source
+
+            Move container rootfs to another storage:
+              $ pvectl move disk ct 200 rootfs --target storage2
+
+            Move container mount point with bandwidth cap (KiB/s):
+              $ pvectl move disk ct 200 mp0 --target storage2 --bandwidth 10240
+
+            Block until completion:
+              $ pvectl move disk vm 100 scsi0 --target storage2 --wait
+
+          NOTES
+            --target is required and must be a valid storage on the source node.
+
+            --format is only valid for VMs (raw, qcow2, vmdk). It is rejected
+            for containers because the LXC API does not accept a format.
+
+            --bandwidth is in KiB/s, matching the Proxmox API directly. The
+            operation defaults to the datacenter/storage move limit when omitted.
+
+            For VMs, allowed disk keys include ide0..ide3, scsi0..scsi30,
+            virtio0..virtio15, sata0..sata5, efidisk0, tpmstate0, unused*.
+            For containers, allowed volume keys include rootfs, mp0..mp255,
+            unused*.
+
+          SEE ALSO
+            pvectl help migrate         Move a VM/container to another node
+            pvectl help clone           Clone a VM or container
+            pvectl help get storage     List storages on the cluster
+        HELP
+        cli.arg_name "SUBJECT RESOURCE_TYPE ID DISK"
+        cli.command :move do |c|
+          c.desc "Target storage (required)"
+          c.flag [:target, :t], arg_name: "STORAGE"
+
+          c.desc "Target disk format (VM only): raw, qcow2, or vmdk"
+          c.flag [:format, :f], arg_name: "FORMAT"
+
+          c.desc "Delete source disk after successful copy"
+          c.switch [:"delete-source"], negatable: false
+
+          c.desc "Bandwidth limit in KiB/s"
+          c.flag [:bandwidth, :b], type: Integer, arg_name: "KIBPS"
+
+          c.desc "Wait for the task to complete (sync mode)"
+          c.switch [:wait], negatable: false
+
+          c.desc "Timeout in seconds for sync operations (default: 600)"
+          c.flag [:timeout], type: Integer, arg_name: "SECONDS"
+
+          c.desc "Skip confirmation prompt"
+          c.switch [:yes, :y], negatable: false
+
+          c.action do |global_options, options, args|
+            subject = args.shift
+            resource_type = args.shift
+
+            exit_code =
+              if subject != "disk"
+                $stderr.puts "Error: Unknown subject: #{subject.inspect}"
+                $stderr.puts "Valid subjects: disk"
+                ExitCodes::USAGE_ERROR
+              else
+                case resource_type
+                when "vm"
+                  Commands::MoveDiskVm.execute(args, options, global_options)
+                when "container", "ct"
+                  Commands::MoveDiskContainer.execute(args, options, global_options)
+                else
+                  $stderr.puts "Error: Unknown resource type: #{resource_type}"
+                  $stderr.puts "Valid types: vm, container, ct"
+                  ExitCodes::USAGE_ERROR
+                end
+              end
+
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      RESOURCE_TYPE = :vm
+      SUPPORTED_RESOURCES = %w[vm].freeze
+    end
+  end
+end