pvectl 0.2.0

data/lib/pvectl/commands/edit_resource_command.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for resource edit commands.
+    #
+    # Template method pattern: provides common edit workflow
+    # (config loading, editor session, diff display, dry-run)
+    # while specialization classes define resource-specific hooks.
+    #
+    # @abstract Include this module and implement template methods.
+    #
+    # @example Specialization
+    #   class EditVm
+    #     include EditResourceCommand
+    #     private
+    #     def resource_label = "VM"
+    #     def resource_id_label = "VMID"
+    #     # ...
+    #   end
+    #
+    module EditResourceCommand
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the edit command.
+        #
+        # @param args [Array<String>] command arguments
+        # @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 module is included.
+      #
+      # @param base [Class] the class including this module
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Initializes an edit command.
+      #
+      # @param args [Array<String>] command arguments
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(args, options, global_options)
+        @args = args
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the edit command.
+      #
+      # Loads configuration, builds the edit service, and runs it.
+      # Handles cancelled edits, successful updates with diff display,
+      # dry-run mode, and errors.
+      #
+      # @return [Integer] exit code
+      def execute
+        resource_id = @args.first
+        return usage_error("#{resource_id_label} is required") unless resource_id
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+        service = build_edit_service(connection)
+        result = service.execute(**execute_params(resource_id))
+
+        if result.nil?
+          $stdout.puts "Edit cancelled, no changes made."
+          return ExitCodes::SUCCESS
+        end
+
+        if result.successful?
+          display_diff(result)
+          if @options[:"dry-run"]
+            $stdout.puts "(dry-run mode — no changes applied)"
+          else
+            $stdout.puts "#{resource_label} #{resource_id} updated successfully."
+          end
+          ExitCodes::SUCCESS
+        else
+          $stderr.puts "Error: #{result.error}"
+          ExitCodes::GENERAL_ERROR
+        end
+      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
+
+      private
+
+      # @return [String] human label for resource ("VM" or "container")
+      def resource_label
+        raise NotImplementedError, "#{self.class} must implement #resource_label"
+      end
+
+      # @return [String] human label for resource ID ("VMID" or "CTID")
+      def resource_id_label
+        raise NotImplementedError, "#{self.class} must implement #resource_id_label"
+      end
+
+      # Builds execution parameters from resource ID.
+      #
+      # @param resource_id [String] resource identifier (converted by specializations)
+      # @return [Hash] parameters for the edit service (e.g. { vmid: 100 })
+      def execute_params(resource_id)
+        raise NotImplementedError, "#{self.class} must implement #execute_params"
+      end
+
+      # Builds the edit service for the given connection.
+      #
+      # @param connection [Connection] API connection
+      # @return [Object] edit service instance
+      def build_edit_service(connection)
+        raise NotImplementedError, "#{self.class} must implement #build_edit_service"
+      end
+
+      # Displays a formatted diff from the operation result.
+      #
+      # @param result [Models::OperationResult] operation result with diff in resource
+      # @return [void]
+      def display_diff(result)
+        diff = result.resource&.dig(:diff)
+        return unless diff
+        return if diff[:changed].empty? && diff[:added].empty? && diff[:removed].empty?
+
+        $stdout.puts "\nChanges:"
+        $stdout.puts Pvectl::ConfigSerializer.format_diff(diff)
+        $stdout.puts ""
+      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[:dry_run] = true if @options[:"dry-run"]
+        opts
+      end
+
+      # Builds an editor session from the --editor option.
+      #
+      # @return [EditorSession, nil] editor session or nil if no --editor flag
+      def build_editor_session
+        editor_cmd = @options[:editor]
+        return nil unless editor_cmd
+
+        Pvectl::EditorSession.new(
+          editor: ->(path) { system(editor_cmd, path) }
+        )
+      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/edit_vm.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl edit vm` command.
+    #
+    # Includes EditResourceCommand for shared workflow and overrides
+    # template methods with VM-specific behavior.
+    #
+    # @example Basic usage
+    #   pvectl edit vm 100
+    #
+    # @example With custom editor
+    #   pvectl edit vm 100 --editor nano
+    #
+    # @example Dry-run mode
+    #   pvectl edit vm 100 --dry-run
+    #
+    class EditVm
+      include EditResourceCommand
+
+      # Registers the edit command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Edit a resource configuration"
+        cli.long_desc <<~HELP
+          Open a VM, container, node, or volume configuration in your text
+          editor. The configuration is presented as YAML for easy editing.
+          Changes are applied via the Proxmox API when you save and close
+          the editor.
+
+          EXAMPLES
+            Edit a VM configuration:
+              $ pvectl edit vm 100
+
+            Edit a container with a specific editor:
+              $ pvectl edit container 200 --editor nano
+
+            Edit a node configuration:
+              $ pvectl edit node pve1
+
+            Edit node DNS resolver settings:
+              $ pvectl edit dns pve1
+
+            Edit volume properties:
+              $ pvectl edit volume vm 100 scsi0
+
+            Edit /etc/hosts on a node:
+              $ pvectl edit hosts pve1
+
+            Preview changes without applying:
+              $ pvectl edit vm 100 --dry-run
+
+          NOTES
+            Uses $EDITOR environment variable by default, falling back to vi.
+            Override with --editor flag.
+
+            In --dry-run mode, shows the diff between current and edited
+            configuration without applying changes to Proxmox.
+
+            Supported resource types: vm, container (ct), node, volume, dns, hosts.
+
+            For DNS, the node identifier is given as a positional argument
+            (pvectl edit dns NODE). DNS settings include search domain and
+            up to three nameservers (dns1, dns2, dns3).
+
+            For volumes, syntax is: pvectl edit volume <vm|container> <id> <disk>
+
+            For hosts, the node identifier is given as a positional argument
+            (pvectl edit hosts NODE). The /etc/hosts file is edited as raw
+            text — Proxmox requires the pvelocalhost entry to remain present
+            and will reject updates removing it.
+
+            Not all configuration keys can be changed while a VM is running.
+            Proxmox will reject invalid changes with an error message.
+
+          SEE ALSO
+            pvectl help describe        View current configuration (read-only)
+            pvectl help create          Create a new resource
+            pvectl help set             Set individual resource properties
+        HELP
+        cli.arg_name "RESOURCE_TYPE RESOURCE_ID"
+        cli.command :edit do |c|
+          c.desc "Override editor command (default: $EDITOR or vi)"
+          c.flag [:editor], arg_name: "CMD"
+
+          c.desc "Show diff without applying changes"
+          c.switch [:"dry-run"], negatable: false
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+            resource_ids = args
+
+            exit_code = case resource_type
+            when "vm"
+              Commands::EditVm.execute(resource_ids, options, global_options)
+            when "container", "ct"
+              Commands::EditContainer.execute(resource_ids, options, global_options)
+            when "node"
+              Commands::EditNode.execute(resource_ids, options, global_options)
+            when "volume"
+              Commands::EditVolume.execute(resource_ids, options, global_options)
+            when "dns"
+              Commands::EditDns.execute(resource_ids, options, global_options)
+            when "hosts"
+              Commands::EditHosts.execute(resource_ids, options, global_options)
+            else
+              $stderr.puts "Error: Unknown resource type: #{resource_type}"
+              $stderr.puts "Valid types: vm, container, node, volume, dns, hosts"
+              ExitCodes::USAGE_ERROR
+            end
+
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      private
+
+      # @return [String] human label for VM resources
+      def resource_label
+        "VM"
+      end
+
+      # @return [String] human label for VM IDs
+      def resource_id_label
+        "VMID"
+      end
+
+      # Builds execution parameters from a VM ID.
+      #
+      # @param resource_id [String] VMID (converted to Integer)
+      # @return [Hash] parameters for the edit service
+      def execute_params(resource_id)
+        { vmid: resource_id.to_i }
+      end
+
+      # Builds the VM edit service.
+      #
+      # @param connection [Connection] API connection
+      # @return [Services::EditVm] VM edit service
+      def build_edit_service(connection)
+        vm_repo = Pvectl::Repositories::Vm.new(connection)
+        Pvectl::Services::EditVm.new(
+          vm_repository: vm_repo,
+          editor_session: build_editor_session,
+          options: service_options
+        )
+      end
+    end
+  end
+end

data/lib/pvectl/commands/edit_volume.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl edit volume` command.
+    #
+    # Does NOT use EditResourceCommand template — has custom flow due to
+    # different argument structure (resource_type + id + disk).
+    #
+    # @example Edit volume properties
+    #   pvectl edit volume vm 100 scsi0
+    #
+    # @example With custom editor
+    #   pvectl edit volume vm 100 scsi0 --editor nano
+    #
+    # @example Dry-run mode
+    #   pvectl edit volume vm 100 scsi0 --dry-run
+    #
+    class EditVolume
+      # Class methods for command execution.
+      module ClassMethods
+        # Executes the edit volume command.
+        #
+        # @param args [Array<String>] command arguments
+        # @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
+
+      extend ClassMethods
+
+      # @param args [Array<String>] command arguments
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(args, options, global_options)
+        @args = args
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the edit volume command.
+      #
+      # @return [Integer] exit code
+      def execute
+        resource_type = @args[0]
+        resource_id = @args[1]
+        disk = @args[2]
+
+        return usage_error("Resource type required (vm, container)") unless resource_type
+        return usage_error("Resource ID is required") unless resource_id
+        return usage_error("Volume name is required (e.g., scsi0, rootfs)") unless disk
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        node = resolve_node(resource_id.to_i, connection, resource_type)
+        return ExitCodes::NOT_FOUND unless node
+
+        repo = build_repository(connection, resource_type)
+        service = Pvectl::Services::EditVolume.new(
+          repository: repo,
+          resource_type: resource_type_symbol(resource_type),
+          editor_session: build_editor_session,
+          options: service_options
+        )
+        result = service.execute(id: resource_id.to_i, disk: disk, node: node)
+
+        if result.nil?
+          $stdout.puts "Edit cancelled, no changes made."
+          return ExitCodes::SUCCESS
+        end
+
+        if result.successful?
+          if @options[:"dry-run"]
+            $stdout.puts "(dry-run mode — no changes applied)"
+          else
+            $stdout.puts "Volume #{disk} on #{resource_type} #{resource_id} updated successfully."
+          end
+          ExitCodes::SUCCESS
+        else
+          $stderr.puts "Error: #{result.error}"
+          ExitCodes::GENERAL_ERROR
+        end
+      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
+
+      private
+
+      # Resolves node for a resource.
+      #
+      # @param resource_id [Integer] resource ID
+      # @param connection [Connection] API connection
+      # @param resource_type [String] resource type
+      # @return [String, nil] node name or nil
+      def resolve_node(resource_id, connection, resource_type)
+        return @options[:node] if @options[:node]
+
+        resolver = Pvectl::Utils::ResourceResolver.new(connection)
+        resolved = resolver.resolve(resource_id)
+
+        unless resolved
+          label = resource_type == "vm" ? "VM" : "container"
+          $stderr.puts "Error: #{label} #{resource_id} not found"
+          return nil
+        end
+
+        resolved[:node]
+      end
+
+      # Builds repository for resource type.
+      #
+      # @param connection [Connection] API connection
+      # @param resource_type [String] resource type
+      # @return [Repositories::Vm, Repositories::Container] repository
+      def build_repository(connection, resource_type)
+        case resource_type
+        when "vm"
+          Pvectl::Repositories::Vm.new(connection)
+        when "container", "ct"
+          Pvectl::Repositories::Container.new(connection)
+        else
+          raise ArgumentError, "Unknown resource type: #{resource_type}"
+        end
+      end
+
+      # Converts string resource type to symbol.
+      #
+      # @param resource_type [String] resource type
+      # @return [Symbol] :vm or :container
+      def resource_type_symbol(resource_type)
+        case resource_type
+        when "vm" then :vm
+        when "container", "ct" then :container
+        else :vm
+        end
+      end
+
+      # Builds an editor session from the --editor option.
+      #
+      # @return [EditorSession, nil] editor session or nil
+      def build_editor_session
+        editor_cmd = @options[:editor]
+        return nil unless editor_cmd
+
+        Pvectl::EditorSession.new(
+          editor: ->(path) { system(editor_cmd, path) }
+        )
+      end
+
+      # Builds service options from command options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:dry_run] = true if @options[:"dry-run"]
+        opts
+      end
+
+      # Loads configuration.
+      #
+      # @return [void]
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: @global_options[:config])
+        @config = service.current_config
+      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