pvectl 0.2.0

data/lib/pvectl/commands/set_resource_command.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for resource set commands.
+    #
+    # Template method pattern: provides common set workflow
+    # (config loading, key-value parsing, diff display, dry-run)
+    # while specialization classes define resource-specific hooks.
+    #
+    # @abstract Include this module and implement template methods.
+    #
+    # @example Specialization
+    #   class SetVm
+    #     include SetResourceCommand
+    #     private
+    #     def resource_label = "VM"
+    #     def resource_id_label = "VMID"
+    #     # ...
+    #   end
+    #
+    module SetResourceCommand
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the set 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 a set 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 set command.
+      #
+      # @return [Integer] exit code
+      def execute
+        resource_id = @args.first
+        return usage_error("#{resource_id_label} is required") unless resource_id
+
+        key_values = parse_key_values(@args[1..])
+        return usage_error("At least one key=value pair is required") if key_values.empty?
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+        service = build_set_service(connection)
+        result = service.execute(**execute_params(resource_id, key_values))
+
+        if result.nil?
+          $stdout.puts "No changes detected."
+          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
+      def resource_label
+        raise NotImplementedError, "#{self.class} must implement #resource_label"
+      end
+
+      # @return [String] human label for resource ID
+      def resource_id_label
+        raise NotImplementedError, "#{self.class} must implement #resource_id_label"
+      end
+
+      # Builds execution parameters.
+      #
+      # @param resource_id [String] resource identifier
+      # @param key_values [Hash] parsed key-value pairs
+      # @return [Hash] parameters for the service
+      def execute_params(resource_id, key_values)
+        raise NotImplementedError, "#{self.class} must implement #execute_params"
+      end
+
+      # Builds the set service.
+      #
+      # @param connection [Connection] API connection
+      # @return [Object] set service instance
+      def build_set_service(connection)
+        raise NotImplementedError, "#{self.class} must implement #build_set_service"
+      end
+
+      # Parses key=value pairs from argument list.
+      #
+      # @param args [Array<String>] arguments like ["memory=4096", "cores=2"]
+      # @return [Hash] parsed pairs { "memory" => "4096", "cores" => "2" }
+      def parse_key_values(args)
+        pairs = {}
+        (args || []).each do |arg|
+          unless arg.include?("=")
+            $stderr.puts "Warning: Ignoring argument without '=': #{arg}"
+            next
+          end
+          key, value = arg.split("=", 2)
+          pairs[key] = value
+        end
+        pairs
+      end
+
+      # Displays a formatted diff from the operation result.
+      #
+      # @param result [Models::OperationResult] operation result
+      # @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.
+      #
+      # @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
+
+      # Returns service options.
+      #
+      # @return [Hash] service options
+      def service_options
+        opts = {}
+        opts[:dry_run] = true if @options[:"dry-run"]
+        opts
+      end
+    end
+  end
+end

data/lib/pvectl/commands/set_vm.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl set vm` command.
+    #
+    # Includes SetResourceCommand for shared workflow and overrides
+    # template methods with VM-specific behavior.
+    #
+    # Also registers the top-level `set` command with all resource types.
+    #
+    # @example Basic usage
+    #   pvectl set vm 100 memory=4096 cores=2
+    #
+    # @example Dry-run mode
+    #   pvectl set vm 100 memory=8192 --dry-run
+    #
+    class SetVm
+      include SetResourceCommand
+
+      # Registers the set command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Set a resource property (non-interactive)"
+        cli.long_desc <<~HELP
+          Set configuration properties on a resource without opening an editor.
+          Accepts key=value pairs as arguments. This is the non-interactive
+          counterpart to the edit command.
+
+          EXAMPLES
+            Set VM memory and CPU:
+              $ pvectl set vm 100 memory=4096 cores=2
+
+            Set container hostname:
+              $ pvectl set container 200 hostname=web01
+
+            Resize a volume:
+              $ pvectl set volume vm 100 scsi0 size=+10G
+
+            Set volume cache mode:
+              $ pvectl set volume vm 100 scsi0 cache=writeback
+
+            Set node description:
+              $ pvectl set node pve1 description="Production node"
+
+            Change node timezone:
+              $ pvectl set node pve1 timezone=Europe/Warsaw
+
+            Preview changes without applying:
+              $ pvectl set vm 100 memory=8192 --dry-run
+
+          NOTES
+            Volume resize (size=) is irreversible. A confirmation prompt is shown
+            unless --yes is specified.
+
+            Keys are passed directly to the Proxmox API. Use Proxmox documentation
+            to find valid configuration keys for each resource type.
+
+          SEE ALSO
+            pvectl help edit        Interactive configuration editor
+            pvectl help describe    View current configuration
+        HELP
+        cli.arg_name "RESOURCE_TYPE RESOURCE_ID [SUB_ID] KEY=VALUE [KEY=VALUE ...]"
+        cli.command :set do |c|
+          c.desc "Skip confirmation prompt"
+          c.switch [:yes, :y], negatable: false
+
+          c.desc "Target node name"
+          c.flag [:node, :n], arg_name: "NODE"
+
+          c.desc "Show diff without applying changes"
+          c.switch [:"dry-run"], negatable: false
+
+          c.action do |global_options, options, args|
+            resource_type = args.shift
+
+            exit_code = case resource_type
+            when "vm"
+              Commands::SetVm.execute(args, options, global_options)
+            when "container", "ct"
+              Commands::SetContainer.execute(args, options, global_options)
+            when "volume", "vol"
+              Commands::SetVolume.execute(args, options, global_options)
+            when "node"
+              Commands::SetNode.execute(args, options, global_options)
+            when nil
+              $stderr.puts "Error: Resource type required (vm, container, volume, node)"
+              ExitCodes::USAGE_ERROR
+            else
+              $stderr.puts "Error: Unknown resource type: #{resource_type}"
+              $stderr.puts "Valid types: vm, container, volume, node"
+              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
+      # @param key_values [Hash] parsed key-value pairs
+      # @return [Hash] parameters for the set service
+      def execute_params(resource_id, key_values)
+        { vmid: resource_id.to_i, params: key_values }
+      end
+
+      # Builds the VM set service.
+      #
+      # @param connection [Connection] API connection
+      # @return [Services::SetVm] VM set service
+      def build_set_service(connection)
+        vm_repo = Pvectl::Repositories::Vm.new(connection)
+        Pvectl::Services::SetVm.new(
+          vm_repository: vm_repo,
+          options: service_options
+        )
+      end
+    end
+  end
+end

data/lib/pvectl/commands/set_volume.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl set volume` command.
+    #
+    # Does NOT use SetResourceCommand template — has custom flow due to
+    # different argument structure (resource_type + id + disk + key=value).
+    #
+    # @example Resize volume
+    #   pvectl set volume vm 100 scsi0 size=+10G
+    #
+    # @example Set cache mode
+    #   pvectl set volume vm 100 scsi0 cache=writeback
+    #
+    # @example Mixed operations
+    #   pvectl set volume vm 100 scsi0 size=+10G cache=writeback --yes
+    #
+    class SetVolume
+      # Class methods for command execution.
+      module ClassMethods
+        # Executes the set 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
+
+      # Initializes a set volume 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 set volume command.
+      #
+      # @return [Integer] exit code
+      def execute
+        resource_type = @args[0]
+        resource_id = @args[1]
+        disk = @args[2]
+        key_value_args = @args[3..] || []
+
+        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
+
+        key_values = parse_key_values(key_value_args)
+        return usage_error("At least one key=value pair is required") if key_values.empty?
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        node = resolve_node(resource_id.to_i, connection, resource_type)
+        return ExitCodes::NOT_FOUND unless node
+
+        # Confirmation for resize operations
+        if key_values.key?("size") && !@options[:yes]
+          return ExitCodes::SUCCESS unless confirm_resize(resource_id, disk, key_values["size"])
+        end
+
+        repo = build_repository(connection, resource_type)
+        service = Pvectl::Services::SetVolume.new(
+          repository: repo,
+          resource_type: resource_type_symbol(resource_type)
+        )
+        result = service.execute(id: resource_id.to_i, disk: disk, params: key_values, node: node)
+
+        output_result(result)
+
+        result.successful? ? ExitCodes::SUCCESS : ExitCodes::GENERAL_ERROR
+      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
+
+      # Parses key=value pairs from argument list.
+      #
+      # @param args [Array<String>] arguments
+      # @return [Hash] parsed pairs
+      def parse_key_values(args)
+        pairs = {}
+        args.each do |arg|
+          unless arg.include?("=")
+            $stderr.puts "Warning: Ignoring argument without '=': #{arg}"
+            next
+          end
+          key, value = arg.split("=", 2)
+          pairs[key] = value
+        end
+        pairs
+      end
+
+      # 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
+
+      # Confirms resize operation.
+      #
+      # @param resource_id [String] resource ID
+      # @param disk [String] disk name
+      # @param size [String] size value
+      # @return [Boolean] true if should proceed
+      def confirm_resize(resource_id, disk, size)
+        $stdout.puts "Resize volume #{disk} on resource #{resource_id}:"
+        $stdout.puts "  New size: #{size}"
+        $stdout.puts ""
+        $stdout.puts "This action is IRREVERSIBLE — volumes cannot be shrunk via API."
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      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
+
+      # Outputs operation result.
+      #
+      # @param result [Models::VolumeOperationResult] operation result
+      # @return [void]
+      def output_result(result)
+        presenter = Pvectl::Presenters::VolumeOperationResult.new
+        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
+
+      # 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

data/lib/pvectl/commands/shared_config_parsers.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared parser methods for CLI flag values.
+    #
+    # Provides reusable methods that parse --disk, --net, --cloud-init,
+    # --mp flags through their respective Parsers. Included by create
+    # and clone commands to avoid parser logic duplication.
+    #
+    # Expects +@options+ (a Hash of CLI flag values) to be available
+    # in the including class.
+    #
+    # @example Including in a command class
+    #   class CreateVm
+    #     include SharedConfigParsers
+    #     # ...
+    #   end
+    #
+    module SharedConfigParsers
+      # Parses VM disk configuration strings through the DiskConfig parser.
+      #
+      # @return [Array<Hash<Symbol, String>>] parsed disk configurations
+      # @raise [ArgumentError] if any disk string is invalid
+      def parse_vm_disks
+        Array(@options[:disk]).map { |d| Parsers::DiskConfig.parse(d) }
+      end
+
+      # Parses VM network configuration strings through the NetConfig parser.
+      #
+      # @return [Array<Hash<Symbol, String>>] parsed network configurations
+      # @raise [ArgumentError] if any net string is invalid
+      def parse_vm_nets
+        Array(@options[:net]).map { |n| Parsers::NetConfig.parse(n) }
+      end
+
+      # Parses cloud-init configuration string and converts to Proxmox params.
+      #
+      # @return [Hash<Symbol, untyped>] Proxmox-compatible cloud-init parameters
+      # @raise [ArgumentError] if the cloud-init string is invalid
+      def parse_vm_cloud_init
+        config = Parsers::CloudInitConfig.parse(@options[:"cloud-init"])
+        Parsers::CloudInitConfig.to_proxmox_params(config)
+      end
+
+      # Parses LXC mountpoint configuration strings through the LxcMountConfig parser.
+      #
+      # @return [Array<Hash<Symbol, String>>] parsed mountpoint configurations
+      # @raise [ArgumentError] if any mountpoint string is invalid
+      def parse_ct_mountpoints
+        Array(@options[:mp]).map { |m| Parsers::LxcMountConfig.parse(m) }
+      end
+
+      # Parses LXC network configuration strings through the LxcNetConfig parser.
+      #
+      # @return [Array<Hash<Symbol, String>>] parsed network configurations
+      # @raise [ArgumentError] if any net string is invalid
+      def parse_ct_nets
+        Array(@options[:net]).map { |n| Parsers::LxcNetConfig.parse(n) }
+      end
+
+      # Builds a VM config parameters hash from CLI options.
+      #
+      # Extracts VM-specific configuration keys from @options, parsing
+      # disk, network, and cloud-init flags through their respective parsers.
+      # Nil values are compacted out.
+      #
+      # @return [Hash<Symbol, untyped>] VM configuration parameters
+      # @raise [ArgumentError] if any parser validation fails
+      def build_vm_config_params
+        params = {
+          cores: @options[:cores],
+          sockets: @options[:sockets],
+          cpu_type: @options[:"cpu-type"],
+          numa: @options[:numa],
+          memory: @options[:memory],
+          balloon: @options[:balloon],
+          scsihw: @options[:scsihw],
+          cdrom: @options[:cdrom],
+          bios: @options[:bios],
+          boot_order: @options[:"boot-order"],
+          machine: @options[:machine],
+          efidisk: @options[:efidisk],
+          agent: @options[:agent],
+          ostype: @options[:ostype],
+          tags: @options[:tags]
+        }
+
+        params[:disks] = parse_vm_disks if @options[:disk]
+        params[:nets] = parse_vm_nets if @options[:net]
+        params[:cloud_init] = parse_vm_cloud_init if @options[:"cloud-init"]
+
+        params.compact
+      end
+
+      # Builds a container config parameters hash from CLI options.
+      #
+      # Extracts container-specific configuration keys from @options, parsing
+      # rootfs, mountpoint, and network flags through their respective parsers.
+      # Nil values are compacted out.
+      #
+      # @return [Hash<Symbol, untyped>] container configuration parameters
+      # @raise [ArgumentError] if any parser validation fails
+      def build_ct_config_params
+        params = {
+          cores: @options[:cores],
+          memory: @options[:memory],
+          swap: @options[:swap],
+          tags: @options[:tags],
+          features: @options[:features],
+          password: @options[:password],
+          ssh_public_keys: @options[:"ssh-public-keys"],
+          onboot: @options[:onboot],
+          startup: @options[:startup]
+        }
+
+        params[:rootfs] = Parsers::LxcMountConfig.parse(@options[:rootfs]) if @options[:rootfs]
+        params[:mountpoints] = parse_ct_mountpoints if @options[:mp]
+        params[:nets] = parse_ct_nets if @options[:net]
+        params[:privileged] = @options[:privileged]
+
+        params.compact
+      end
+    end
+  end
+end