pvectl 0.2.0

data/lib/pvectl/commands/push.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Push command -- applies YAML manifests to the Proxmox cluster.
+    # Creates resources that don't exist, updates those that do.
+    #
+    # @example Register with CLI
+    #   Push.register(cli)
+    class Push
+      RESOURCE_TYPES = {
+        "vm" => :vm,
+        "vms" => :vm,
+        "container" => :container,
+        "containers" => :container,
+        "ct" => :container
+      }.freeze
+
+      # Registers the push command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Push YAML manifest to cluster (create or update)"
+        cli.long_desc <<~HELP
+          DESCRIPTION
+            Applies resource configuration from YAML manifest files to the
+            Proxmox cluster. Creates resources that don't exist, updates those
+            that do. Shows a diff and asks for confirmation before applying.
+
+          EXAMPLES
+            $ pvectl push vm -f vm-100.yaml
+            $ pvectl push vm -f ./manifests/
+            $ pvectl push -f ./manifests/
+            $ pvectl push vm -f vm-100.yaml --dry-run
+            $ pvectl push vm -f vm-100.yaml --yes
+            $ pvectl push vm -f vm-new.yaml            # no vmid → auto-assign
+            $ pvectl pull vm 100 | pvectl push --yes
+            $ cat vm-100.yaml | pvectl push vm --dry-run
+
+          NOTES
+            Without -f, reads YAML from stdin (pipe-friendly).
+            With -f, reads from file or directory (repeatable).
+            Without resource type, reads kind from each manifest.
+            If metadata.vmid is omitted, a new VMID is auto-assigned
+            and the source YAML file is updated with the assigned ID.
+            Stdin mode requires --yes or --dry-run (no interactive prompt).
+            With --yes, skips confirmation (useful for CI/CD).
+            With --dry-run, shows diff without applying changes.
+
+          SEE ALSO
+            pull, edit, create, delete
+        HELP
+
+        cli.command :push do |c|
+          c.flag [:f, :file], desc: "YAML file or directory to push", multiple: true
+          c.switch [:y, :yes], desc: "Auto-confirm without prompting", negatable: false
+          c.switch [:"dry-run"], desc: "Show diff without applying", negatable: false
+
+          c.action do |global_options, options, args|
+            Push.new(args, options, global_options).execute
+          end
+        end
+      end
+
+      # @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
+        @stdin_mode = false
+      end
+
+      # Executes the push command.
+      #
+      # @return [Integer] exit code
+      def execute
+        args = @args.dup
+        filter_type = parse_resource_type(args)
+
+        unless args.empty?
+          return usage_error("Unexpected arguments: #{args.join(', ')}. Use -f to specify files.")
+        end
+
+        yaml_contents = read_input
+        return usage_error("No YAML content provided. Use -f <path> or pipe YAML to stdin.") if yaml_contents.empty?
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+        service, pull_service = build_services(connection)
+
+        result = service.prepare_batch(yaml_contents, filter_type: filter_type)
+
+        # Report errors and skipped
+        result[:errors].each { |e| $stderr.puts "Error: #{e}" }
+        result[:skipped].each { |s| $stderr.puts "Info: #{s}" }
+
+        if result[:plans].empty?
+          if result[:errors].empty?
+            $stdout.puts "No changes to apply."
+          end
+
+          # Refresh unchanged file-backed manifests with server-assigned values
+          # (MAC addresses, volume names, UUIDs, etc.)
+          refresh_unchanged_manifests(result[:unchanged] || [], pull_service)
+
+          return result[:errors].empty? ? ExitCodes::SUCCESS : ExitCodes::GENERAL_ERROR
+        end
+
+        # Display plans
+        display_plans(result[:plans])
+
+        if @options[:"dry-run"]
+          $stdout.puts "\n(dry-run mode -- no changes applied)"
+          return ExitCodes::SUCCESS
+        end
+
+        # Confirm unless --yes
+        unless @options[:yes]
+          if @stdin_mode
+            return usage_error("Stdin mode requires --yes or --dry-run (no interactive prompt available)")
+          end
+          $stdout.print "\nApply #{result[:plans].length} change(s)? [y/N] "
+          answer = $stdin.gets&.strip&.downcase
+          unless answer == "y" || answer == "yes"
+            $stdout.puts "Cancelled."
+            return ExitCodes::SUCCESS
+          end
+        end
+
+        # Apply
+        apply_result = service.apply(result[:plans])
+
+        apply_result[:results].each do |r|
+          if r[:success]
+            $stdout.puts "#{r[:action].capitalize}d #{type_label_for(r)} #{r[:vmid]} successfully."
+          else
+            $stderr.puts "Error: Failed to #{r[:action]} #{r[:vmid]}: #{r[:error]}"
+          end
+        end
+
+        # Refresh source manifest files with current server state
+        refresh_manifests(apply_result[:results], result[:plans], pull_service)
+        refresh_unchanged_manifests(result[:unchanged] || [], pull_service)
+
+        apply_result[:errors].empty? ? 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
+
+      # Reads YAML input from -f flag (files/directories) or stdin.
+      #
+      # @return [Array<Hash>] array of { filename: String, content: String }
+      def read_input
+        file_flag = @options[:file]
+        if file_flag && !file_flag.empty?
+          @stdin_mode = false
+          collect_yaml_contents(Array(file_flag))
+        else
+          @stdin_mode = true
+          read_stdin
+        end
+      end
+
+      # Reads YAML content from stdin.
+      #
+      # @return [Array<Hash>] array of { filename: String, content: String }
+      def read_stdin
+        if $stdin.tty?
+          $stderr.puts "Error: No input. Use -f <path> or pipe YAML to stdin."
+          return []
+        end
+        content = $stdin.read
+        return [] if content.nil? || content.strip.empty?
+
+        [{ filename: "stdin", content: content }]
+      end
+
+      # Parses and removes the optional resource type from the argument list.
+      #
+      # @param args [Array<String>] argument list (modified in place)
+      # @return [Symbol, nil] :vm or :container, or nil if first arg is not a type
+      def parse_resource_type(args)
+        return nil if args.empty?
+
+        first = args.first.downcase
+        if RESOURCE_TYPES.key?(first)
+          args.shift
+          RESOURCE_TYPES[first]
+        end
+      end
+
+      # Collects YAML file contents from given paths (files or directories).
+      #
+      # @param paths [Array<String>] file or directory paths
+      # @return [Array<Hash>] array of { filename: String, content: String, path: String? }
+      def collect_yaml_contents(paths)
+        contents = []
+        paths.each do |path|
+          if File.directory?(path)
+            Dir.glob(File.join(path, "*.{yaml,yml}")).sort.each do |file|
+              contents << { filename: File.basename(file), content: File.read(file), path: File.expand_path(file) }
+            end
+          elsif File.file?(path)
+            contents << { filename: File.basename(path), content: File.read(path), path: File.expand_path(path) }
+          else
+            $stderr.puts "Error: File not found: #{path}"
+          end
+        end
+        contents
+      end
+
+      # Displays push plans with diffs to stdout.
+      #
+      # @param plans [Array<Hash>] prepared push plans
+      # @return [void]
+      def display_plans(plans)
+        plans.each do |plan|
+          label = plan[:type] == :container ? "Container" : "VM"
+          if plan[:action] == :update
+            $stdout.puts "\n#{label} #{plan[:vmid]} (#{plan[:node]}) -- UPDATE:"
+            $stdout.puts ConfigSerializer.format_diff(plan[:diff])
+            if plan[:resize_ops]&.any?
+              plan[:resize_ops].each do |op|
+                $stdout.puts "  (disk resize: #{op[:disk]} -> #{op[:size]})"
+              end
+            end
+          elsif plan[:action] == :create
+            id_note = plan[:auto_id] ? " (auto-assigned)" : ""
+            $stdout.puts "\n#{label} #{plan[:vmid]}#{id_note} (#{plan[:node]}) -- CREATE:"
+            plan[:params].each do |key, val|
+              $stdout.puts "  + #{key}: #{val}"
+            end
+          end
+        end
+      end
+
+      # Returns a human-readable type label for a result hash.
+      #
+      # @param result [Hash] apply result with optional :type key
+      # @return [String] "VM" or "Container"
+      def type_label_for(result)
+        result[:type] == :container ? "Container" : "VM"
+      end
+
+      # Refreshes source manifest files with the current server state after
+      # successful apply. Re-pulls each resource and overwrites the source file,
+      # ensuring local manifests include server-assigned values (volume names,
+      # MAC addresses, etc.).
+      #
+      # @param results [Array<Hash>] apply results
+      # @param plans [Array<Hash>] original plans (same order as results)
+      # @param pull_service [Services::PullConfig] pull service for re-pulling
+      # @return [void]
+      def refresh_manifests(results, plans, pull_service)
+        results.each_with_index do |r, idx|
+          next unless r[:success]
+
+          plan = plans[idx]
+          source_path = plan[:source_path]
+          next unless source_path && File.file?(source_path)
+
+          refresh_manifest_file(source_path, plan[:type], plan[:vmid], pull_service)
+        end
+      end
+
+      # Refreshes file-backed manifests that had no changes to apply.
+      # Re-pulls each resource to fill in server-assigned values (MAC addresses,
+      # volume names, UUIDs, etc.) that may not be in the local manifest.
+      #
+      # @param unchanged [Array<Hash>] unchanged entries from prepare_batch
+      # @param pull_service [Services::PullConfig] pull service for re-pulling
+      # @return [void]
+      def refresh_unchanged_manifests(unchanged, pull_service)
+        unchanged.each do |entry|
+          next unless entry[:source_path] && File.file?(entry[:source_path])
+
+          refresh_manifest_file(entry[:source_path], entry[:type], entry[:vmid], pull_service)
+        end
+      end
+
+      # Re-pulls a single resource and writes the updated YAML to the source file.
+      #
+      # @param path [String] source manifest file path
+      # @param type [Symbol] :vm or :container
+      # @param vmid [Integer] resource ID
+      # @param pull_service [Services::PullConfig] pull service
+      # @return [void]
+      def refresh_manifest_file(path, type, vmid, pull_service)
+        pull_result = pull_service.execute(type: type, ids: [vmid])
+        return if pull_result[:manifests].empty?
+
+        File.write(path, pull_result[:manifests].first[:yaml])
+        $stderr.puts "Refreshed #{path}"
+      rescue StandardError => e
+        $stderr.puts "Warning: Could not refresh #{path}: #{e.message}"
+      end
+
+      # Builds the PushConfig and PullConfig services with shared repositories.
+      #
+      # @param connection [Connection] API connection
+      # @return [Array(Services::PushConfig, Services::PullConfig)]
+      def build_services(connection)
+        vm_repo = Pvectl::Repositories::Vm.new(connection)
+        ct_repo = Pvectl::Repositories::Container.new(connection)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        push_service = Pvectl::Services::PushConfig.new(
+          vm_repository: vm_repo,
+          container_repository: ct_repo,
+          task_repository: task_repo
+        )
+
+        pull_service = Pvectl::Services::PullConfig.new(
+          vm_repository: vm_repo,
+          container_repository: ct_repo
+        )
+
+        [push_service, pull_service]
+      end
+
+      # Loads configuration from file/env.
+      #
+      # @return [void]
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: @global_options[:config])
+        @config = service.current_config
+      end
+
+      # Prints a usage error and returns the USAGE_ERROR exit code.
+      #
+      # @param message [String] error message
+      # @return [Integer] USAGE_ERROR exit code
+      def usage_error(message)
+        $stderr.puts "Error: #{message}"
+        ExitCodes::USAGE_ERROR
+      end
+    end
+  end
+end

data/lib/pvectl/commands/reset.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl reset` command.
+    #
+    # Resets one or more virtual machines (hard reset).
+    #
+    # @example Reset a single VM
+    #   pvectl reset vm 100
+    #
+    # @example Reset with JSON output
+    #   pvectl reset vm 100 -o json
+    #
+    class Reset
+      include VmLifecycleCommand
+
+      # Registers the reset command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Reset virtual machines (hard reset)"
+        cli.long_desc <<~HELP
+          Hard reset one or more virtual machines. Equivalent to pressing the
+          physical reset button — the VM is immediately restarted without
+          graceful OS shutdown.
+
+          Only available for VMs. Containers do not support hard reset.
+
+          EXAMPLES
+            Hard reset a VM:
+              $ pvectl reset vm 100
+
+            Reset multiple VMs:
+              $ pvectl reset vm 100 101 102
+
+          NOTES
+            May cause data loss or filesystem corruption. Use 'pvectl restart'
+            for a graceful reboot instead.
+
+            Not available for containers — use 'pvectl restart ct' instead.
+
+          SEE ALSO
+            pvectl help restart         Graceful reboot (VMs and containers)
+            pvectl help stop            Hard stop without restart
+        HELP
+        cli.arg_name "RESOURCE_TYPE [ID...]"
+        cli.command :reset 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 = :reset
+    end
+  end
+end

data/lib/pvectl/commands/resource_lifecycle_command.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for lifecycle commands across resource types.
+    #
+    # Template method pattern: provides common flow (validate, resolve,
+    # confirm, execute, output) while specialization modules define
+    # resource-specific hooks.
+    #
+    # @abstract Include a specialization module (VmLifecycleCommand,
+    #   ContainerLifecycleCommand) instead of this one directly.
+    #
+    # @example Specialization module pattern
+    #   module VmLifecycleCommand
+    #     def self.included(base)
+    #       base.include(ResourceLifecycleCommand)
+    #     end
+    #
+    #     private
+    #     def supported_resources = %w[vm]
+    #     def resource_label = "VM"
+    #     # ...
+    #   end
+    #
+    module ResourceLifecycleCommand
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the lifecycle command.
+        #
+        # @param resource_type [String, nil] resource type (vm, ct)
+        # @param resource_ids [Array<String>, String, nil] resource identifiers
+        # @param options [Hash] command options
+        # @param global_options [Hash] global CLI options
+        # @return [Integer] exit code
+        def execute(resource_type, resource_ids, options, global_options)
+          new(resource_type, resource_ids, 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 lifecycle command.
+      #
+      # @param resource_type [String, nil] resource type
+      # @param resource_ids [Array<String>, String, nil] resource identifiers
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      def initialize(resource_type, resource_ids, options, global_options)
+        @resource_type = resource_type
+        @resource_ids = Array(resource_ids).compact
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the lifecycle command.
+      #
+      # @return [Integer] exit code
+      def execute
+        return usage_error("Resource type required (#{supported_resources.join(', ')})") unless @resource_type
+        return usage_error("Unsupported resource: #{@resource_type}") unless supported_resources.include?(@resource_type)
+
+        if @resource_ids.empty? && !@options[:all] && selector_strings.empty?
+          return usage_error("#{resource_id_label}, --all, or -l selector required")
+        end
+
+        perform_operation
+      end
+
+      private
+
+      # --- Template methods (override in specialization) ---
+
+      # @return [Array<String>] supported resource type strings
+      def supported_resources
+        raise NotImplementedError, "#{self.class} must implement #supported_resources"
+      end
+
+      # @return [String] human label for resource ("VM", "container")
+      def resource_label
+        raise NotImplementedError, "#{self.class} must implement #resource_label"
+      end
+
+      # @return [String] human label for resource ID ("VMID", "CTID")
+      def resource_id_label
+        raise NotImplementedError, "#{self.class} must implement #resource_id_label"
+      end
+
+      # @return [Object] repository for this resource type
+      def build_repository(connection)
+        raise NotImplementedError, "#{self.class} must implement #build_repository"
+      end
+
+      # @return [Object] lifecycle service
+      def build_service(repo, task_repo, options)
+        raise NotImplementedError, "#{self.class} must implement #build_service"
+      end
+
+      # @return [Object] presenter for results
+      def build_presenter
+        raise NotImplementedError, "#{self.class} must implement #build_presenter"
+      end
+
+      # @return [Object] selector for filtering
+      def build_selector(strings)
+        raise NotImplementedError, "#{self.class} must implement #build_selector"
+      end
+
+      # --- Shared implementation ---
+
+      # Performs the lifecycle operation.
+      #
+      # @return [Integer] exit code
+      def perform_operation
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        repo = build_repository(connection)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        resources = resolve_resources(repo)
+        return no_resources_found if resources.empty?
+        return Pvectl::ExitCodes::SUCCESS unless confirm_operation(resources)
+
+        service = build_service(repo, task_repo, service_options)
+        results = service.execute(operation_name, resources)
+
+        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}"
+        Pvectl::ExitCodes::GENERAL_ERROR
+      end
+
+      # Resolves resources based on resource_ids, --all flag, or selectors.
+      #
+      # @param repo [Object] resource repository
+      # @return [Array<Object>] resolved resources
+      def resolve_resources(repo)
+        resources = if @options[:all]
+                      repo.list(node: @options[:node])
+                    elsif @resource_ids.any?
+                      resolved = @resource_ids.map { |id| repo.get(id.to_i) }.compact
+                      resolved = resolved.select { |r| r.node == @options[:node] } if @options[:node]
+                      resolved
+                    else
+                      return [] if selector_strings.empty?
+
+                      repo.list(node: @options[:node])
+                    end
+
+        apply_selectors(resources)
+      end
+
+      # Returns selector strings from options.
+      #
+      # @return [Array<String>] selector strings
+      def selector_strings
+        Array(@options[:selector] || @options[:l])
+      end
+
+      # Applies selectors to resource collection.
+      #
+      # @param resources [Array<Object>] resources to filter
+      # @return [Array<Object>] filtered resources
+      def apply_selectors(resources)
+        return resources if selector_strings.empty?
+
+        selector = build_selector(selector_strings)
+        selector.apply(resources)
+      end
+
+      # Confirms multi-resource operation with user.
+      #
+      # @param resources [Array<Object>] resources to operate on
+      # @return [Boolean] true if operation should proceed
+      def confirm_operation(resources)
+        return true if resources.size == 1
+        return true if @options[:yes]
+
+        $stdout.puts "You are about to #{operation_name} #{resources.size} #{resource_label}s:"
+        resources.each { |r| $stdout.puts "  - #{r.vmid} (#{r.name || 'unnamed'}) on #{r.node}" }
+        $stdout.puts ""
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      end
+
+      # Returns the operation name for this command.
+      #
+      # @return [Symbol] operation name
+      def operation_name
+        self.class::OPERATION
+      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[:wait] = true if @options[:wait]
+        opts[:fail_fast] = true if @options[:"fail-fast"]
+        opts
+      end
+
+      # Outputs operation results using the configured formatter.
+      #
+      # @param results [Array<Object>] operation results
+      # @return [void]
+      def output_results(results)
+        presenter = build_presenter
+        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<Object>] operation results
+      # @return [Integer] exit code
+      def determine_exit_code(results)
+        return Pvectl::ExitCodes::SUCCESS if results.all?(&:successful?)
+        return Pvectl::ExitCodes::SUCCESS if results.all?(&:pending?)
+
+        Pvectl::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}"
+        Pvectl::ExitCodes::USAGE_ERROR
+      end
+
+      # Outputs no resources found error and returns exit code.
+      #
+      # @return [Integer] exit code
+      def no_resources_found
+        msg = if @options[:all] || selector_strings.any?
+                @options[:node] ? "No #{resource_label}s found on node #{@options[:node]}" : "No #{resource_label}s found matching criteria"
+              else
+                "No #{resource_label}s found for given #{resource_id_label}s"
+              end
+        $stderr.puts "Error: #{msg}"
+        Pvectl::ExitCodes::NOT_FOUND
+      end
+    end
+  end
+end