pvectl 0.2.0

data/lib/pvectl/commands/resource_registry.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Abstract base class for command resource registries.
+    #
+    # Provides handler registration and lookup. Each subclass maintains
+    # its own isolated set of handlers via +self.inherited+ callback.
+    #
+    # @abstract Subclass for each command namespace (Get, Top, Logs).
+    #
+    # @example Creating a command-specific registry
+    #   module Pvectl::Commands::Logs
+    #     class ResourceRegistry < Pvectl::Commands::ResourceRegistry; end
+    #   end
+    #
+    class ResourceRegistry
+      @handlers = {}
+
+      def self.inherited(subclass)
+        super
+        subclass.instance_variable_set(:@handlers, {})
+      end
+
+      class << self
+        # Registers a handler class for a resource type.
+        #
+        # @param resource_type [String, Symbol] primary resource type name
+        # @param handler_class [Class] handler class
+        # @param aliases [Array<String, Symbol>] alternative names
+        # @return [void]
+        def register(resource_type, handler_class, aliases: [])
+          @handlers[resource_type.to_s] = handler_class
+          aliases.each { |a| @handlers[a.to_s] = handler_class }
+        end
+
+        # Returns a new handler instance for the resource type.
+        #
+        # @param resource_type [String, Symbol, nil] resource type name
+        # @return [Object, nil] handler instance or nil
+        def for(resource_type)
+          return nil if resource_type.nil?
+
+          handler_class = @handlers[resource_type.to_s]
+          handler_class&.new
+        end
+
+        # Returns all registered type names (including aliases).
+        #
+        # @return [Array<String>] registered type names
+        def registered_types
+          @handlers.keys
+        end
+
+        # Checks if a resource type is registered.
+        #
+        # @param resource_type [String, Symbol] resource type name
+        # @return [Boolean]
+        def registered?(resource_type)
+          @handlers.key?(resource_type.to_s)
+        end
+
+        # Clears all registered handlers.
+        #
+        # @return [void]
+        # @api private
+        def reset!
+          @handlers = {}
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/commands/restart.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl restart` command.
+    #
+    # Restarts one or more virtual machines (reboot).
+    #
+    # @example Restart a single VM
+    #   pvectl restart vm 100
+    #
+    # @example Restart with sync mode
+    #   pvectl restart vm 100 --wait
+    #
+    class Restart
+      include VmLifecycleCommand
+
+      # Registers the restart command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Restart virtual machines or containers (reboot)"
+        cli.long_desc <<~HELP
+          Reboot one or more virtual machines or containers. Sends a reboot
+          signal to the guest OS for a clean restart.
+
+          EXAMPLES
+            Reboot a VM:
+              $ pvectl restart vm 100
+
+            Reboot a container:
+              $ pvectl restart ct 200
+
+            Reboot all VMs with a specific tag:
+              $ pvectl restart vm --all -l tags=webserver --yes
+
+          NOTES
+            For VMs, this sends an ACPI reboot signal (requires guest agent or
+            ACPI support). For containers, uses LXC reboot.
+
+            For a hard reset (equivalent to pressing the reset button), use
+            'pvectl reset' instead (VMs only).
+
+          SEE ALSO
+            pvectl help reset           Hard reset (VMs only)
+            pvectl help shutdown        Graceful shutdown without restart
+        HELP
+        cli.arg_name "RESOURCE_TYPE [ID...]"
+        cli.command :restart do |c|
+          SharedFlags.lifecycle(c)
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+            resource_ids = args
+            exit_code = case resource_type
+            when "container", "ct"
+              RestartContainer.execute(resource_type, resource_ids, options, global_options)
+            else
+              execute(resource_type, resource_ids, options, global_options)
+            end
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      OPERATION = :restart
+    end
+  end
+end

data/lib/pvectl/commands/restart_container.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl restart container` command.
+    #
+    # Restarts one or more LXC containers (reboot).
+    #
+    # @example Restart a single container
+    #   pvectl restart container 200
+    #
+    class RestartContainer
+      include ContainerLifecycleCommand
+
+      OPERATION = :restart
+    end
+  end
+end

data/lib/pvectl/commands/restore_backup.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl restore backup` command.
+    #
+    # Restores a backup identified by its full volume ID (volid)
+    # to a new or existing VM/container.
+    # Requires --vmid and --yes flags.
+    #
+    # @example Restore a backup to new VM
+    #   pvectl restore backup local:backup/vzdump-qemu-100-xxx.vma.zst --vmid 200 --yes
+    #
+    # @example Restore with overwrite
+    #   pvectl restore backup local:backup/vzdump-qemu-100-xxx.vma.zst --vmid 100 --force --yes
+    #
+    class RestoreBackup
+      # Registers the restore command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Restore a resource from backup"
+        cli.long_desc <<~HELP
+          Restore a virtual machine or container from a backup (vzdump) volume.
+          Creates a new or overwrites an existing VM/container with the backup data.
+
+          EXAMPLES
+            Restore to a new VMID:
+              $ pvectl restore backup local:backup/vzdump-qemu-100-2026_01_01.vma.zst --vmid 200 --yes
+
+            Restore to specific storage:
+              $ pvectl restore backup local:backup/vzdump-qemu-100-2026_01_01.vma.zst --vmid 200 --storage local-lvm --yes
+
+            Overwrite existing VM:
+              $ pvectl restore backup local:backup/vzdump-qemu-100-2026_01_01.vma.zst --vmid 100 --force --yes
+
+            Restore and start immediately:
+              $ pvectl restore backup local:backup/vzdump-qemu-100-2026_01_01.vma.zst --vmid 200 --start --yes
+
+            Regenerate unique properties (MAC, UUID):
+              $ pvectl restore backup local:backup/vzdump-qemu-100-2026_01_01.vma.zst --vmid 200 --unique --yes
+
+          NOTES
+            --vmid is required to specify the target VM/container ID.
+
+            --force overwrites an existing VM/container with the same VMID.
+            Without it, restore fails if the VMID already exists.
+
+            --unique regenerates MAC addresses and other unique properties,
+            useful when restoring alongside the original VM.
+
+            Use 'pvectl get backups' to find backup volume IDs.
+
+          SEE ALSO
+            pvectl help create backup   Create a new backup
+            pvectl help get backups     List available backups
+            pvectl help delete backup   Delete backup volumes
+        HELP
+        cli.arg_name "RESOURCE_TYPE VOLID"
+        cli.command :restore do |c|
+          c.desc "Target VMID (required)"
+          c.flag [:vmid], arg_name: "VMID", type: Integer
+
+          c.desc "Target storage"
+          c.flag [:storage], arg_name: "STORAGE"
+
+          c.desc "Overwrite existing VM/container"
+          c.switch [:force], negatable: false
+
+          c.desc "Start after restore"
+          c.switch [:start], negatable: false
+
+          c.desc "Regenerate unique properties (MAC, UUID)"
+          c.switch [:unique], negatable: false
+
+          c.desc "Skip confirmation prompt (REQUIRED)"
+          c.switch [:yes, :y], negatable: false
+
+          c.desc "Timeout in seconds"
+          c.flag [:timeout], type: Integer, arg_name: "SECONDS"
+
+          c.desc "Force async mode"
+          c.switch [:async], negatable: false
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+            volid = args.first
+
+            exit_code = case resource_type
+            when "backup"
+              Commands::RestoreBackup.execute(resource_type, volid, options, global_options)
+            else
+              $stderr.puts "Error: Unknown resource type: #{resource_type}"
+              $stderr.puts "Valid types: backup"
+              ExitCodes::USAGE_ERROR
+            end
+
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      # Executes the restore backup command.
+      #
+      # @param resource_type [String, nil] resource type (backup)
+      # @param volid [String, nil] backup volume ID
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      # @return [Integer] exit code
+      def self.execute(resource_type, volid, options, global_options)
+        new(resource_type, volid, options, global_options).execute
+      end
+
+      # Initializes a restore backup command.
+      #
+      # @param resource_type [String, nil] resource type (backup)
+      # @param volid [String, nil] backup volume ID
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(resource_type, volid, options, global_options)
+        @resource_type = resource_type
+        @volid = volid
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the restore backup command.
+      #
+      # @return [Integer] exit code
+      def execute
+        return usage_error("Resource type required (backup)") unless @resource_type == "backup"
+        return usage_error("Backup volid is required") if @volid.nil? || @volid.empty?
+        return usage_error("--vmid is required") unless @options[:vmid]
+        return usage_error("Confirmation required: use --yes to confirm restore") unless @options[:yes]
+
+        perform_operation
+      end
+
+      private
+
+      # Performs the backup restore operation.
+      #
+      # @return [Integer] exit code
+      def perform_operation
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        backup_repo = Pvectl::Repositories::Backup.new(connection)
+        resolver = Pvectl::Utils::ResourceResolver.new(connection)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        service = Pvectl::Services::Backup.new(
+          backup_repo: backup_repo,
+          resource_resolver: resolver,
+          task_repo: task_repo,
+          options: service_options
+        )
+
+        result = service.restore(
+          @volid,
+          vmid: @options[:vmid],
+          storage: @options[:storage],
+          force: @options[:force] || false,
+          start: @options[:start] || false,
+          unique: @options[:unique] || false
+        )
+
+        output_results([result])
+        determine_exit_code([result])
+      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 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
+
+      # Builds service options from command options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:timeout] = @options[:timeout] if @options[:timeout]
+        opts[:async] = true if @options[:async]
+        opts
+      end
+
+      # Outputs operation results using the configured formatter.
+      #
+      # @param results [Array<Models::OperationResult>] operation 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 based on results.
+      #
+      # @param results [Array<Models::OperationResult>] operation 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 and returns exit code.
+      #
+      # @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/resume.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl resume` command.
+    #
+    # Resumes one or more suspended virtual machines.
+    #
+    # @example Resume a single VM
+    #   pvectl resume vm 100
+    #
+    # @example Resume with JSON output
+    #   pvectl resume vm 100 -o json
+    #
+    class Resume
+      include VmLifecycleCommand
+
+      # Registers the resume command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Resume suspended virtual machines"
+        cli.long_desc <<~HELP
+          Resume one or more suspended (hibernated) virtual machines. Restores
+          the VM's memory state from disk and continues execution.
+
+          Only available for VMs. Containers do not support resume.
+
+          EXAMPLES
+            Resume a suspended VM:
+              $ pvectl resume vm 100
+
+            Resume all suspended VMs:
+              $ pvectl resume vm --all -l status=suspended --yes
+
+          SEE ALSO
+            pvectl help suspend         Suspend (hibernate) VMs
+            pvectl help start           Start a stopped VM (no state restore)
+        HELP
+        cli.arg_name "RESOURCE_TYPE [ID...]"
+        cli.command :resume do |c|
+          SharedFlags.lifecycle(c)
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+            resource_ids = args
+            exit_code = execute(resource_type, resource_ids, options, global_options)
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      OPERATION = :resume
+    end
+  end
+end

data/lib/pvectl/commands/rollback_snapshot.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl rollback snapshot` command.
+    #
+    # Rolls back a VM/container to a snapshot.
+    # Requires --yes flag for confirmation. Only supports single VMID.
+    #
+    # @example Rollback to snapshot
+    #   pvectl rollback snapshot 100 before-upgrade --yes
+    #
+    # @example Start after rollback (LXC only)
+    #   pvectl rollback snapshot 100 before-upgrade --yes --start
+    #
+    class RollbackSnapshot
+      # Registers the rollback command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Rollback to a snapshot"
+        cli.long_desc <<~HELP
+          Rollback a virtual machine or container to a previous snapshot,
+          restoring its disk (and optionally RAM) state to the snapshot point.
+
+          WARNING: All changes made after the snapshot will be lost.
+
+          EXAMPLES
+            Rollback a VM to a snapshot:
+              $ pvectl rollback snapshot 100 before-upgrade --yes
+
+            Rollback and start the VM after:
+              $ pvectl rollback snapshot 100 before-upgrade --yes --start
+
+            Async rollback:
+              $ pvectl rollback snapshot 100 before-upgrade --yes --async
+
+          NOTES
+            Rollback always operates on a single VM/container (not batch).
+
+            The VM/container will be stopped during rollback if running.
+
+            --yes is required — rollback is a destructive operation that
+            discards all changes since the snapshot.
+
+          SEE ALSO
+            pvectl help create snapshot Create a snapshot before changes
+            pvectl help get snapshots   List available snapshots
+            pvectl help describe snapshot  View snapshot details
+        HELP
+        cli.arg_name "RESOURCE_TYPE ID SNAPSHOT_NAME"
+        cli.command :rollback do |c|
+          c.desc "Skip confirmation prompt (REQUIRED for destructive operations)"
+          c.switch [:yes, :y], negatable: false
+
+          c.desc "Start VM/container after rollback (LXC only)"
+          c.switch [:start], negatable: false
+
+          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.action do |global_options, options, args|
+            resource_type = args.shift
+            exit_code = Commands::RollbackSnapshot.execute(
+              resource_type,
+              args,
+              options,
+              global_options
+            )
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      SUPPORTED_RESOURCES = %w[snapshot].freeze
+
+      # Executes the rollback snapshot command.
+      #
+      # @param resource_type [String, nil] resource type (snapshot)
+      # @param args [Array<String>, String, nil] VMID and snapshot name
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      # @return [Integer] exit code
+      def self.execute(resource_type, args, options, global_options)
+        new(resource_type, args, options, global_options).execute
+      end
+
+      # Initializes a rollback snapshot command.
+      #
+      # @param resource_type [String, nil] resource type (snapshot)
+      # @param args [Array<String>, String, nil] VMID and snapshot name
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(resource_type, args, options, global_options)
+        @resource_type = resource_type
+        @args = Array(args).compact
+        @options = options
+        @global_options = global_options
+        @too_many_args = false
+        parse_args!
+      end
+
+      # Executes the rollback snapshot command.
+      #
+      # @return [Integer] exit code
+      def execute
+        return usage_error("Resource type required (snapshot)") unless @resource_type
+        return usage_error("Unsupported resource: #{@resource_type}") unless SUPPORTED_RESOURCES.include?(@resource_type)
+        return usage_error("Rollback supports only single VMID") if @too_many_args
+        return usage_error("VMID and snapshot name required") if @vmid.nil? || @snapshot_name.nil?
+        return usage_error("Confirmation required: use --yes to confirm rollback") unless @options[:yes]
+
+        perform_operation
+      end
+
+      private
+
+      # Parses arguments: exactly 2 args - VMID and snapshot name.
+      #
+      # @return [void]
+      def parse_args!
+        if @args.size == 2
+          @vmid = @args[0].to_i
+          @snapshot_name = @args[1]
+        elsif @args.size > 2
+          # Too many args - rollback only supports single VMID
+          @vmid = nil
+          @snapshot_name = nil
+          @too_many_args = true
+        else
+          @vmid = nil
+          @snapshot_name = nil
+        end
+      end
+
+      # Performs the snapshot rollback 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
+        )
+
+        result = service.rollback(@vmid, @snapshot_name, start: @options[:start] || false)
+        results = [result]
+
+        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 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
+
+      # Builds service options from command options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:timeout] = @options[:timeout] if @options[:timeout]
+        opts[:async] = true if @options[:async]
+        opts
+      end
+
+      # Outputs operation results using the configured formatter.
+      #
+      # @param results [Array<Models::OperationResult>] operation 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 based on results.
+      #
+      # @param results [Array<Models::OperationResult>] operation 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 and returns exit code.
+      #
+      # @param message [String] error message
+      # @return [Integer] exit code
+      def usage_error(message)
+        $stderr.puts "Error: #{message}"
+        ExitCodes::USAGE_ERROR
+      end
+    end
+  end
+end