pvectl 0.2.0

data/lib/pvectl/commands/delete_command.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Delete-specific functionality built on IrreversibleCommand.
+    #
+    # Adds delete-specific behavior:
+    # - Confirmation message mentioning disk destruction
+    # - --keep-disks and --purge options in service_options
+    # - Delegates to Services::ResourceDelete
+    #
+    # @example Including in a command class
+    #   class DeleteVm
+    #     include DeleteCommand
+    #     RESOURCE_TYPE = :vm
+    #     SUPPORTED_RESOURCES = %w[vm].freeze
+    #   end
+    #
+    module DeleteCommand
+      include IrreversibleCommand
+
+      # Hook called when module is included.
+      #
+      # @param base [Class] the class including this module
+      def self.included(base)
+        base.extend(IrreversibleCommand::ClassMethods)
+      end
+
+      private
+
+      # Returns confirmation message for delete operation.
+      #
+      # @param resources [Array] resources to delete
+      # @return [String] confirmation message
+      def confirm_message(resources)
+        type_name = resource_type_symbol == :vm ? "VM" : "container"
+        type_plural = resource_type_symbol == :vm ? "VMs" : "containers"
+
+        if resources.size == 1
+          r = resources.first
+          "You are about to delete #{type_name} #{r.vmid} (#{r.name || 'unnamed'}) on #{r.node}."
+        else
+          lines = ["You are about to delete #{resources.size} #{type_plural}:"]
+          resources.each { |r| lines << "  - #{r.vmid} (#{r.name || 'unnamed'}) on #{r.node}" }
+          lines.join("\n")
+        end
+      end
+
+      # Returns irreversibility warning for delete.
+      #
+      # @return [String] warning text
+      def irreversibility_warning
+        type_plural = resource_type_symbol == :vm ? "VMs" : "containers"
+        if @options[:"keep-disks"]
+          "This action is IRREVERSIBLE. Disks will be preserved."
+        else
+          "This action is IRREVERSIBLE and will destroy the #{type_plural} and their disks."
+        end
+      end
+
+      # Confirms delete operation — always required (uses --yes flag, not --force).
+      #
+      # @param resources [Array] Resources to delete
+      # @return [Boolean] true if operation should proceed
+      def confirm_operation(resources)
+        return true if @options[:yes]
+
+        $stdout.puts confirm_message(resources)
+        $stdout.puts ""
+        $stdout.puts irreversibility_warning
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      end
+
+      # Performs the delete service call.
+      #
+      # @param resources [Array] resources to delete
+      # @param connection [Connection] API connection
+      # @return [Array<Models::OperationResult>] results
+      def perform_service_call(resources, connection)
+        vm_repo = Pvectl::Repositories::Vm.new(connection)
+        container_repo = Pvectl::Repositories::Container.new(connection)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        service = Pvectl::Services::ResourceDelete.new(
+          vm_repository: vm_repo,
+          container_repository: container_repo,
+          task_repository: task_repo,
+          options: service_options
+        )
+
+        service.execute(resource_type_symbol, resources)
+      end
+
+      # Builds presenter for delete results.
+      #
+      # @return [Presenters::Base] presenter
+      def build_presenter
+        if resource_type_symbol == :vm
+          Pvectl::Presenters::VmOperationResult.new
+        else
+          Pvectl::Presenters::ContainerOperationResult.new
+        end
+      end
+
+      # Builds service options with delete-specific flags.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = super
+        opts[:keep_disks] = true if @options[:"keep-disks"]
+        opts[:purge] = true if @options[:purge]
+        opts
+      end
+    end
+  end
+end

data/lib/pvectl/commands/delete_container.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl delete container` command.
+    #
+    # Deletes one or more LXC containers from the cluster.
+    # Always requires confirmation (--yes to skip).
+    # Running containers must be stopped first or use --force.
+    #
+    # @example Delete a single container
+    #   pvectl delete container 200 --yes
+    #
+    # @example Delete using ct alias
+    #   pvectl delete ct 200 --yes
+    #
+    # @example Delete multiple containers
+    #   pvectl delete container 200 201 202 --yes
+    #
+    # @example Force delete running container
+    #   pvectl delete container 200 --force --yes
+    #
+    class DeleteContainer
+      include DeleteCommand
+
+      RESOURCE_TYPE = :container
+      SUPPORTED_RESOURCES = %w[container ct].freeze
+    end
+  end
+end

data/lib/pvectl/commands/delete_snapshot.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl delete snapshot` sub-command.
+    #
+    # Deletes snapshots from VMs/containers. Snapshot name is the first
+    # positional argument, or use --all to delete ALL snapshots.
+    # VMIDs are specified via --vmid flag. Without --vmid, operates cluster-wide.
+    #
+    # @example Delete named snapshot
+    #   pvectl delete snapshot before-upgrade --vmid 100 --yes
+    #
+    # @example Delete all snapshots from a VM
+    #   pvectl delete snapshot --all --vmid 100 --yes
+    #
+    # @example Delete named snapshot cluster-wide
+    #   pvectl delete snapshot before-upgrade --yes
+    #
+    class DeleteSnapshot
+      VMID_PATTERN = /\A[1-9]\d{0,8}\z/
+
+      # Registers as a sub-command under the parent delete command.
+      #
+      # @param parent [GLI::Command] the parent delete command
+      # @return [void]
+      def self.register_subcommand(parent)
+        parent.desc "Delete snapshots from VMs or containers"
+        parent.long_desc <<~HELP
+          Delete snapshots from VMs and containers.
+
+          EXAMPLES
+            Delete a specific snapshot from a VM:
+              $ pvectl delete snapshot before-upgrade --vmid 100 --yes
+
+            Delete a snapshot from all VMs that have it:
+              $ pvectl delete snapshot before-upgrade --yes
+
+            Delete ALL snapshots from a specific VM:
+              $ pvectl delete snapshot --all --vmid 100 --yes
+
+            Delete ALL snapshots cluster-wide:
+              $ pvectl delete snapshot --all --yes
+
+          NOTES
+            Snapshot deletion is irreversible.
+
+            --all deletes every snapshot, not just the named one. Use with
+            extreme caution, especially without --vmid.
+
+          SEE ALSO
+            pvectl help create snapshot Create snapshots
+            pvectl help rollback        Rollback to a snapshot
+            pvectl help get snapshots   List existing snapshots
+        HELP
+        parent.command :snapshot do |s|
+          s.desc "VM/CT ID (repeatable)"
+          s.flag [:vmid], arg_name: "VMID", multiple: true
+
+          s.action do |global_options, options, args|
+            exit_code = execute(args, options, global_options)
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      # Executes the delete snapshot command.
+      #
+      # @param args [Array<String>] positional args (snapshot name)
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      # @return [Integer] exit code
+      def self.execute(args, options, global_options)
+        new(args, options, global_options).execute
+      end
+
+      # Initializes a delete snapshot command.
+      #
+      # @param args [Array<String>] positional args (snapshot name)
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(args, options, global_options)
+        @args = Array(args)
+        @options = options
+        @global_options = global_options
+        @snapshot_name = @args.first
+        @vmids = parse_vmids(options[:vmid])
+        @node = options[:node]
+        @delete_all = options[:all] || false
+      end
+
+      # Executes the delete snapshot command.
+      #
+      # @return [Integer] exit code
+      def execute
+        return usage_error("Snapshot name or --all required") if @snapshot_name.nil? && !@delete_all
+        return usage_error("Cannot use --all with snapshot name") if @snapshot_name && @delete_all
+        return usage_error("Invalid VMID: #{invalid_vmid}") if invalid_vmid
+
+        return ExitCodes::SUCCESS unless confirm_operation
+
+        perform_operation
+      end
+
+      private
+
+      # Parses --vmid flag values to integer array.
+      #
+      # @param vmid_values [Array<String>, nil] raw vmid values
+      # @return [Array<Integer>] parsed VMIDs
+      def parse_vmids(vmid_values)
+        return [] if vmid_values.nil? || vmid_values.empty?
+
+        Array(vmid_values).map(&:to_i)
+      end
+
+      # Finds first invalid VMID in options.
+      #
+      # @return [String, nil] invalid VMID value or nil
+      def invalid_vmid
+        return nil if @options[:vmid].nil? || @options[:vmid].empty?
+
+        Array(@options[:vmid]).find { |v| !VMID_PATTERN.match?(v.to_s) }
+      end
+
+      # Confirms operation with user prompt.
+      #
+      # @return [Boolean] true if operation should proceed
+      def confirm_operation
+        return true if @options[:yes]
+
+        if @delete_all
+          if @vmids.empty?
+            $stdout.puts "You are about to delete ALL snapshots from ALL VMs/CTs in the cluster."
+          else
+            $stdout.puts "You are about to delete ALL snapshots from #{@vmids.size} VMs:"
+            @vmids.each { |vmid| $stdout.puts "  - #{vmid}" }
+          end
+        else
+          if @vmids.empty?
+            $stdout.puts "You are about to delete snapshot '#{@snapshot_name}' from ALL VMs/CTs in the cluster."
+          elsif @vmids.size == 1
+            $stdout.puts "You are about to delete snapshot '#{@snapshot_name}' from VM #{@vmids.first}."
+          else
+            $stdout.puts "You are about to delete snapshot '#{@snapshot_name}' from #{@vmids.size} VMs:"
+            @vmids.each { |vmid| $stdout.puts "  - #{vmid}" }
+          end
+        end
+        $stdout.puts ""
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      end
+
+      # Performs the snapshot deletion operation.
+      #
+      # @return [Integer] exit code
+      def perform_operation
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        snapshot_repo = Pvectl::Repositories::Snapshot.new(connection)
+        resolver = Pvectl::Utils::ResourceResolver.new(connection)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        service = Pvectl::Services::Snapshot.new(
+          snapshot_repo: snapshot_repo,
+          resource_resolver: resolver,
+          task_repo: task_repo,
+          options: service_options
+        )
+
+        results = if @delete_all
+          service.delete_all(@vmids, node: @node, force: @options[:force] || false)
+        else
+          service.delete(@vmids, @snapshot_name, force: @options[:force] || false, node: @node)
+        end
+
+        output_results(results)
+        determine_exit_code(results)
+      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
+
+      # Loads configuration.
+      #
+      # @return [void]
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: @global_options[:config])
+        @config = service.current_config
+      end
+
+      # Builds service options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:timeout] = @options[:timeout] if @options[:timeout]
+        opts[:async] = true if @options[:async]
+        opts[:fail_fast] = true if @options[:"fail-fast"]
+        opts
+      end
+
+      # Outputs operation results.
+      #
+      # @param results [Array<Models::OperationResult>] results
+      # @return [void]
+      def output_results(results)
+        presenter = Pvectl::Presenters::SnapshotOperationResult.new
+        format = @global_options[:output] || "table"
+        color_flag = @global_options[:color]
+
+        formatter = Pvectl::Formatters::Registry.for(format)
+        output = formatter.format(results, presenter, color: color_flag)
+        puts output
+      end
+
+      # Determines exit code.
+      #
+      # @param results [Array<Models::OperationResult>] results
+      # @return [Integer] exit code
+      def determine_exit_code(results)
+        return ExitCodes::SUCCESS if results.all?(&:successful?)
+        return ExitCodes::SUCCESS if results.all?(&:pending?)
+
+        ExitCodes::GENERAL_ERROR
+      end
+
+      # Outputs usage error.
+      #
+      # @param message [String] error message
+      # @return [Integer] exit code
+      def usage_error(message)
+        $stderr.puts "Error: #{message}"
+        ExitCodes::USAGE_ERROR
+      end
+    end
+  end
+end

data/lib/pvectl/commands/delete_vm.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl delete vm` command.
+    #
+    # Deletes one or more virtual machines from the cluster.
+    # Always requires confirmation (--yes to skip).
+    # Running VMs must be stopped first or use --force.
+    #
+    # @example Delete a single VM
+    #   pvectl delete vm 100 --yes
+    #
+    # @example Delete multiple VMs
+    #   pvectl delete vm 100 101 102 --yes
+    #
+    # @example Force delete running VM
+    #   pvectl delete vm 100 --force --yes
+    #
+    # @example Keep disks after deletion
+    #   pvectl delete vm 100 --keep-disks --yes
+    #
+    class DeleteVm
+      include DeleteCommand
+
+      # Registers the delete command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Delete a resource"
+        cli.long_desc <<~HELP
+          Delete virtual machines, containers, snapshots, or backups.
+
+          Destructive operations require confirmation (--yes flag or interactive
+          prompt). Use --force to stop running resources before deletion.
+
+          SUBCOMMANDS
+            delete vm ID...              Delete virtual machines
+            delete container ID...       Delete LXC containers
+            delete snapshot NAME         Delete snapshots (see: pvectl help delete snapshot)
+            delete backup VOLID...       Delete backup volumes
+
+          EXAMPLES
+            Delete a stopped VM:
+              $ pvectl delete vm 100 --yes
+
+            Force-delete a running VM (stops it first):
+              $ pvectl delete vm 100 --force --yes
+
+            Delete VM but keep its disks:
+              $ pvectl delete vm 100 --keep-disks --yes
+
+            Delete a backup by volume ID:
+              $ pvectl delete backup local:backup/vzdump-qemu-100-2026_01_01.vma.zst --yes
+
+          NOTES
+            Deletion is irreversible. Always verify the resource ID before confirming.
+
+            --force stops a running VM/container before deleting.
+            --purge removes the resource from replication and backup jobs.
+
+          SEE ALSO
+            pvectl help get             List resources to find IDs
+            pvectl help create          Create new resources
+        HELP
+        cli.arg_name "RESOURCE_TYPE [ID...] [NAME]"
+        cli.command :delete do |c|
+          c.desc "Skip confirmation prompt (REQUIRED for destructive operations)"
+          c.switch [:yes, :y], negatable: false
+
+          c.desc "Force stop running VM/container before deletion"
+          c.switch [:force, :f], negatable: false
+
+          c.desc "Keep disks (do not destroy)"
+          c.switch [:"keep-disks"], negatable: false
+
+          c.desc "Remove from HA, replication, and backups"
+          c.switch [:purge], negatable: false
+
+          c.desc "Select all resources of this type"
+          c.switch [:all, :A], negatable: false
+
+          c.desc "Filter by node name"
+          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 "Timeout in seconds for sync operations"
+          c.flag [:timeout], type: Integer, arg_name: "SECONDS"
+
+          c.desc "Force async mode (return task ID immediately)"
+          c.switch [:async], negatable: false
+
+          c.desc "Stop on first error (default: continue and report all)"
+          c.switch [:"fail-fast"], negatable: false
+
+          # Sub-commands
+          DeleteSnapshot.register_subcommand(c)
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+
+            exit_code = case resource_type
+            when "vm"
+              Commands::DeleteVm.execute(resource_type, args, options, global_options)
+            when "container", "ct"
+              Commands::DeleteContainer.execute(resource_type, args, options, global_options)
+            when "backup"
+              Commands::DeleteBackup.execute(resource_type, args, options, global_options)
+            else
+              $stderr.puts "Error: Unknown resource type: #{resource_type}"
+              $stderr.puts "Valid types: vm, container, backup (or use: delete snapshot)"
+              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