pvectl 0.2.0

data/lib/pvectl/commands/ping.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl ping` command.
+    #
+    # Verifies connectivity to the Proxmox cluster by calling the version
+    # endpoint and measuring response time. Provides a quick health check
+    # without detailed resource information.
+    #
+    # @example Basic usage
+    #   pvectl ping
+    #   # Output: OK - Connected to pve1.example.com
+    #
+    # @example Wide output with latency
+    #   pvectl ping -o wide
+    #   # Output: OK - Connected to pve1.example.com | Latency: 45ms
+    #
+    # @example JSON output for scripts
+    #   pvectl ping -o json
+    #   # Output: {"status":"ok","server":"pve1.example.com","latency_ms":45}
+    #
+    class Ping
+      # Registers the ping command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Check connectivity to Proxmox cluster"
+        cli.long_desc <<~HELP
+          Verify connectivity to the Proxmox cluster by calling the version
+          API endpoint and measuring response time.
+
+          EXAMPLES
+            Basic connectivity check:
+              $ pvectl ping
+
+            Wide output with latency:
+              $ pvectl ping -o wide
+
+            JSON output for scripting:
+              $ pvectl ping -o json
+
+          NOTES
+            Uses the configured context (or PROXMOX_HOST environment variable)
+            to determine which server to ping.
+
+            Exit code 0 = connected, exit code 4 = connection error.
+
+          SEE ALSO
+            pvectl help config          Manage cluster configuration
+            pvectl help get nodes       List cluster nodes
+        HELP
+        cli.command :ping do |c|
+          c.action do |global_options, _options, _args|
+            exit_code = execute(global_options)
+            exit exit_code if exit_code != 0
+          end
+        end
+      end
+
+      # Executes the ping command.
+      #
+      # @param global_options [Hash] global CLI options
+      #   - :config [String, nil] path to config file
+      #   - :output [String] output format (table, wide, json, yaml)
+      #   - :color [Boolean, nil] explicit color flag
+      # @return [Integer] exit code (0 for success, 4 for connection error)
+      def self.execute(global_options)
+        new(global_options).execute
+      end
+
+      # Creates a new Ping command instance.
+      #
+      # @param global_options [Hash] global CLI options
+      def initialize(global_options)
+        @global_options = global_options
+        @output_format = global_options[:output] || "table"
+        @color_flag = global_options[:color]
+        @config = nil
+      end
+
+      # Executes the ping operation.
+      #
+      # @return [Integer] exit code
+      def execute
+        load_config
+        connection = Pvectl::Connection.new(@config)
+
+        result = measure_ping(connection)
+        output_result(result, @config.server)
+
+        ExitCodes::SUCCESS
+      rescue Pvectl::Config::ConfigNotFoundError,
+             Pvectl::Config::InvalidConfigError,
+             Pvectl::Config::ContextNotFoundError,
+             Pvectl::Config::ClusterNotFoundError,
+             Pvectl::Config::UserNotFoundError => e
+        # Re-raise config errors to be handled by CLI error handler
+        raise
+      rescue Timeout::Error
+        output_error("Connection timed out", server_url)
+        ExitCodes::CONNECTION_ERROR
+      rescue Errno::ECONNREFUSED
+        output_error("Connection refused", server_url)
+        ExitCodes::CONNECTION_ERROR
+      rescue SocketError => e
+        output_error(e.message, server_url)
+        ExitCodes::CONNECTION_ERROR
+      rescue StandardError => e
+        output_error(e.message, server_url)
+        ExitCodes::CONNECTION_ERROR
+      end
+
+      private
+
+      attr_reader :global_options, :output_format, :color_flag
+
+      # Loads configuration from service.
+      #
+      # @return [Config::Models::ResolvedConfig] the resolved configuration
+      # @raise [Config::ConfigNotFoundError] if config not found
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: global_options[:config])
+        @config = service.current_config
+      end
+
+      # Returns the server URL, or "unknown" if config not loaded.
+      #
+      # @return [String] server URL or "unknown"
+      def server_url
+        @config&.server || "unknown"
+      end
+
+      # Measures ping latency by timing the version API call.
+      #
+      # @param connection [Connection] the connection to use
+      # @return [Hash] result with :latency_ms
+      def measure_ping(connection)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        connection.version
+        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        {
+          latency_ms: ((end_time - start_time) * 1000).round
+        }
+      end
+
+      # Outputs the result based on the selected format.
+      #
+      # @param result [Hash] the ping result
+      # @param server [String] the server URL
+      # @return [void]
+      def output_result(result, server)
+        case output_format
+        when "json"
+          output_json(result, server)
+        when "yaml"
+          output_yaml(result, server)
+        when "wide"
+          output_wide(result, server)
+        else
+          output_simple(server)
+        end
+      end
+
+      # Outputs simple text format.
+      #
+      # @param server [String] the server URL
+      # @return [void]
+      def output_simple(server)
+        pastel = Formatters::ColorSupport.pastel(explicit_flag: color_flag)
+        puts "#{pastel.green('OK')} - Connected to #{extract_host(server)}"
+      end
+
+      # Outputs wide text format with latency.
+      #
+      # @param result [Hash] the ping result
+      # @param server [String] the server URL
+      # @return [void]
+      def output_wide(result, server)
+        pastel = Formatters::ColorSupport.pastel(explicit_flag: color_flag)
+        puts "#{pastel.green('OK')} - Connected to #{extract_host(server)} | " \
+             "Latency: #{result[:latency_ms]}ms"
+      end
+
+      # Outputs JSON format.
+      #
+      # @param result [Hash] the ping result
+      # @param server [String] the server URL
+      # @return [void]
+      def output_json(result, server)
+        require "json"
+        puts JSON.pretty_generate({
+          status: "ok",
+          server: extract_host(server),
+          latency_ms: result[:latency_ms]
+        })
+      end
+
+      # Outputs YAML format.
+      #
+      # @param result [Hash] the ping result
+      # @param server [String] the server URL
+      # @return [void]
+      def output_yaml(result, server)
+        require "yaml"
+        puts YAML.dump({
+          "status" => "ok",
+          "server" => extract_host(server),
+          "latency_ms" => result[:latency_ms]
+        })
+      end
+
+      # Outputs error message.
+      #
+      # @param message [String] the error message
+      # @param server [String] the server URL
+      # @return [void]
+      def output_error(message, server)
+        pastel = Formatters::ColorSupport.pastel(explicit_flag: color_flag)
+        host = extract_host(server)
+
+        case output_format
+        when "json"
+          require "json"
+          puts JSON.pretty_generate({ status: "error", server: host, error: message })
+        when "yaml"
+          require "yaml"
+          puts YAML.dump({ "status" => "error", "server" => host, "error" => message })
+        else
+          $stderr.puts "#{pastel.red('ERROR')} - Cannot connect to #{host}: #{message}"
+        end
+      end
+
+      # Extracts hostname from server URL.
+      #
+      # @param server_url [String] the full server URL
+      # @return [String] the hostname
+      def extract_host(server_url)
+        uri = URI.parse(server_url)
+        uri.host
+      rescue StandardError
+        server_url
+      end
+    end
+  end
+end

data/lib/pvectl/commands/pull.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Pvectl
+  module Commands
+    # Pull command -- exports resource configuration from the Proxmox cluster
+    # as kubectl-like YAML manifest files.
+    #
+    # @example Register with CLI
+    #   Pull.register(cli)
+    class Pull
+      RESOURCE_TYPES = {
+        "vm" => :vm,
+        "vms" => :vm,
+        "container" => :container,
+        "containers" => :container,
+        "ct" => :container
+      }.freeze
+
+      FILE_PREFIXES = {
+        vm: "vm",
+        container: "ct"
+      }.freeze
+
+      # Registers the pull command with the CLI.
+      #
+      # @param cli [GLI::App] the CLI application object
+      # @return [void]
+      def self.register(cli)
+        cli.desc "Pull resource configuration to YAML manifest"
+        cli.long_desc <<~HELP
+          DESCRIPTION
+            Exports resource configuration from the Proxmox cluster as kubectl-like
+            YAML manifest files. Supports single resources, multiple IDs, selectors,
+            and bulk export with --all.
+
+            When writing to files (-f), shows a diff of changes and asks for
+            confirmation before overwriting existing files. Use --yes to skip
+            confirmation or --dry-run to preview changes without writing.
+
+          EXAMPLES
+            $ pvectl pull vm 100
+            $ pvectl pull vm 100 -f vm-100.yaml
+            $ pvectl pull vm 100 -f vm-100.yaml --dry-run
+            $ pvectl pull vm 100 101 102 -f ./manifests/
+            $ pvectl pull vm --all -f ./manifests/ --yes
+            $ pvectl pull vm -f ./manifests/
+            $ pvectl pull vm -l tags=prod -f ./manifests/
+            $ pvectl pull container 200
+
+          NOTES
+            Without -f, YAML is printed to stdout (pipe-friendly).
+            With -f, shows diff against existing files and asks to confirm.
+            With --all or -l, -f must point to a directory.
+            When -f points to a directory with existing manifests and no IDs
+            are given, IDs are inferred from file names (vm-{vmid}.yaml).
+            File naming convention: vm-{vmid}.yaml or ct-{vmid}.yaml.
+
+          SEE ALSO
+            push, get, describe, edit
+        HELP
+
+        cli.command :pull do |c|
+          c.flag [:f, :file], desc: "Output file or directory"
+          c.flag [:l, :selector], desc: "Filter by selector (e.g. tags=prod,status=running)", multiple: true
+          c.switch [:all], desc: "Pull all resources of given type", negatable: false
+          c.switch [:y, :yes], desc: "Auto-confirm without prompting", negatable: false
+          c.switch [:"dry-run"], desc: "Show diff without writing files", negatable: false
+          c.flag [:node], desc: "Limit to specific node"
+
+          c.action do |global_options, options, args|
+            Pull.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
+      end
+
+      # Executes the pull command.
+      #
+      # @return [Integer] exit code
+      def execute
+        resource_type_str = @args.shift
+        return usage_error("Resource type is required (vm, container)") unless resource_type_str
+
+        type = RESOURCE_TYPES[resource_type_str.downcase]
+        return usage_error("Unknown resource type '#{resource_type_str}'. Valid: vm, container") unless type
+
+        ids = @args.map(&:to_i)
+        all = @options[:all]
+        node = @options[:node]
+        output = @options[:file]
+
+        # Auto-infer IDs from existing manifest files in directory
+        if ids.empty? && !all && @options[:selector].nil? && output && directory_output?(output)
+          ids = infer_ids_from_directory(output, type)
+        end
+
+        if ids.empty? && !all && @options[:selector].nil?
+          return usage_error("Provide resource IDs, --all, or -l selector")
+        end
+
+        if (all || @options[:selector]) && output && !directory_output?(output)
+          return usage_error("--all and -l require -f to be a directory (end with /)")
+        end
+
+        selector = build_selector(type)
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+        service = build_service(connection)
+
+        result = service.execute(type: type, ids: ids, all: all, node: node, selector: selector)
+
+        result[:errors].each { |e| $stderr.puts "Error: #{e}" }
+
+        write_output(result[:manifests], type, output)
+
+        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
+
+      def build_service(connection)
+        vm_repo = Pvectl::Repositories::Vm.new(connection)
+        ct_repo = Pvectl::Repositories::Container.new(connection)
+        Pvectl::Services::PullConfig.new(
+          vm_repository: vm_repo,
+          container_repository: ct_repo
+        )
+      end
+
+      def build_selector(type)
+        expressions = @options[:selector]
+        return nil if expressions.nil? || (expressions.is_a?(Array) && expressions.empty?)
+
+        selector_class = type == :container ? Selectors::Container : Selectors::Vm
+        selector_class.new(Array(expressions))
+      end
+
+      # Writes pull results to stdout or files.
+      # For file output, shows diff against existing files and asks for confirmation.
+      #
+      # @param manifests [Array<Hash>] pulled manifests with :yaml and :vmid
+      # @param type [Symbol] :vm or :container
+      # @param output [String, nil] output file/directory or nil for stdout
+      # @return [void]
+      def write_output(manifests, type, output)
+        return if manifests.empty?
+
+        if output.nil?
+          # stdout mode -- no diff, just print
+          manifests.each { |m| $stdout.puts m[:yaml] }
+          return
+        end
+
+        # File output mode -- build operations, show diff, confirm, write
+        operations = build_file_operations(manifests, type, output)
+        actionable = operations.reject { |op| op[:action] == :unchanged }
+
+        if actionable.empty?
+          $stdout.puts "No changes."
+          return
+        end
+
+        display_pull_plan(operations, type)
+
+        if @options[:"dry-run"]
+          $stdout.puts "\n(dry-run mode -- no files written)"
+          return
+        end
+
+        unless @options[:yes]
+          $stdout.print "\nWrite #{actionable.length} file(s)? [y/N] "
+          answer = $stdin.gets&.strip&.downcase
+          unless answer == "y" || answer == "yes"
+            $stdout.puts "Cancelled."
+            return
+          end
+        end
+
+        apply_file_operations(operations)
+      end
+
+      # Builds a list of file operations (create/update/unchanged) for each manifest.
+      #
+      # @param manifests [Array<Hash>] pulled manifests
+      # @param type [Symbol] :vm or :container
+      # @param output [String] output file or directory path
+      # @return [Array<Hash>] operation hashes with :action, :path, :vmid, :yaml, :diff
+      def build_file_operations(manifests, type, output)
+        if manifests.length == 1 && !directory_output?(output)
+          [build_operation(manifests.first, output, type)]
+        else
+          prefix = FILE_PREFIXES[type]
+          manifests.map do |m|
+            filename = "#{prefix}-#{m[:vmid]}.yaml"
+            path = File.join(output, filename)
+            build_operation(m, path, type)
+          end
+        end
+      end
+
+      # Builds a single file operation by comparing new YAML with existing file.
+      #
+      # @param manifest [Hash] manifest with :yaml and :vmid
+      # @param path [String] target file path
+      # @param type [Symbol] :vm or :container
+      # @return [Hash] operation hash
+      def build_operation(manifest, path, type)
+        new_yaml = manifest[:yaml]
+
+        unless File.file?(path)
+          return { action: :create, path: path, vmid: manifest[:vmid], yaml: new_yaml }
+        end
+
+        old_yaml = File.read(path)
+        return { action: :unchanged, path: path, vmid: manifest[:vmid] } if old_yaml == new_yaml
+
+        diff = compute_manifest_diff(old_yaml, new_yaml, type)
+        { action: :update, path: path, vmid: manifest[:vmid], yaml: new_yaml, diff: diff }
+      end
+
+      # Computes a flat config diff between old and new manifest YAML strings.
+      #
+      # @param old_yaml [String] existing file content
+      # @param new_yaml [String] new content from server
+      # @param type [Symbol] :vm or :container
+      # @return [Hash, nil] diff hash or nil on parse error
+      def compute_manifest_diff(old_yaml, new_yaml, type)
+        old_manifest = ManifestSerializer.from_yaml(old_yaml)
+        new_manifest = ManifestSerializer.from_yaml(new_yaml)
+        old_flat = ConfigSerializer.from_nested(old_manifest[:spec], type: type)
+        new_flat = ConfigSerializer.from_nested(new_manifest[:spec], type: type)
+        ConfigSerializer.diff(old_flat, new_flat)
+      rescue StandardError
+        nil
+      end
+
+      # Displays the pull plan with diffs for each file operation.
+      #
+      # @param operations [Array<Hash>] file operations
+      # @param type [Symbol] :vm or :container
+      # @return [void]
+      def display_pull_plan(operations, type)
+        label = type == :container ? "Container" : "VM"
+        operations.each do |op|
+          case op[:action]
+          when :create
+            $stdout.puts "\n#{label} #{op[:vmid]} -- NEW (#{File.basename(op[:path])})"
+          when :update
+            $stdout.puts "\n#{label} #{op[:vmid]} -- UPDATE (#{File.basename(op[:path])}):"
+            if op[:diff] && diff_has_changes?(op[:diff])
+              $stdout.puts ConfigSerializer.format_diff(op[:diff])
+            else
+              $stdout.puts "  (metadata changed)"
+            end
+          when :unchanged
+            $stderr.puts "Info: #{File.basename(op[:path])}: no changes"
+          end
+        end
+      end
+
+      # Checks if a diff hash has any actual changes.
+      #
+      # @param diff [Hash] diff hash from ConfigSerializer.diff
+      # @return [Boolean]
+      def diff_has_changes?(diff)
+        diff[:changed].any? || diff[:added].any? || diff[:removed].any?
+      end
+
+      # Writes files for all actionable operations.
+      #
+      # @param operations [Array<Hash>] file operations
+      # @return [void]
+      def apply_file_operations(operations)
+        written = 0
+        operations.each do |op|
+          next if op[:action] == :unchanged
+
+          dir = File.dirname(op[:path])
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          File.write(op[:path], op[:yaml])
+          written += 1
+        end
+        $stderr.puts "Written #{written} manifest(s)"
+      end
+
+      # Infers resource IDs from existing manifest files in a directory.
+      # Scans for files matching {prefix}-{vmid}.yaml pattern.
+      #
+      # @param directory [String] path to directory
+      # @param type [Symbol] :vm or :container
+      # @return [Array<Integer>] extracted VMIDs
+      def infer_ids_from_directory(directory, type)
+        return [] unless File.directory?(directory)
+
+        prefix = FILE_PREFIXES[type]
+        pattern = File.join(directory, "#{prefix}-*.yaml")
+        Dir.glob(pattern).filter_map do |path|
+          basename = File.basename(path, ".yaml")
+          match = basename.match(/\A#{Regexp.escape(prefix)}-(\d+)\z/)
+          match[1].to_i if match
+        end.sort
+      end
+
+      def directory_output?(path)
+        return false if path.nil?
+
+        path.end_with?("/") || File.directory?(path)
+      end
+
+      def load_config
+        service = Pvectl::Config::Service.new
+        service.load(config: @global_options[:config])
+        @config = service.current_config
+      end
+
+      def usage_error(message)
+        $stderr.puts "Error: #{message}"
+        ExitCodes::USAGE_ERROR
+      end
+    end
+  end
+end