pvectl 0.2.0

data/lib/pvectl/commands/create_backup.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl create backup` command.
+    #
+    # Creates backups for one or more VMs/containers.
+    # Supports multiple VMIDs with optional confirmation prompt.
+    #
+    # @example Create single backup
+    #   pvectl create backup 100 --storage local
+    #
+    # @example Create backup for multiple VMs
+    #   pvectl create backup 100 101 102 --storage nfs --mode snapshot
+    #
+    # @example Create backup with options
+    #   pvectl create backup 100 --storage local --compress zstd --notes "Pre-upgrade" --protected
+    #
+    class CreateBackup
+      SUPPORTED_RESOURCES = %w[backup].freeze
+
+      # Executes the create backup command.
+      #
+      # @param resource_type [String, nil] resource type (backup)
+      # @param resource_ids [Array<String>, String, nil] VM identifiers
+      # @param options [Hash] command options
+      # @param global_options [Hash] global CLI options
+      # @return [Integer] exit code
+      def self.execute(resource_type, resource_ids, options, global_options)
+        new(resource_type, resource_ids, options, global_options).execute
+      end
+
+      # Initializes a create backup command.
+      #
+      # @param resource_type [String, nil] resource type (backup)
+      # @param resource_ids [Array<String>, String, nil] VM 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.map(&:to_i)
+        @options = options
+        @global_options = global_options
+      end
+
+      # Executes the create backup command.
+      #
+      # @return [Integer] exit code
+      def execute
+        return usage_error("Resource type required (backup)") unless @resource_type
+        return usage_error("Unsupported resource: #{@resource_type}") unless SUPPORTED_RESOURCES.include?(@resource_type)
+        return usage_error("At least one VMID is required") if @resource_ids.empty?
+        return usage_error("--storage is required") unless @options[:storage]
+
+        perform_operation
+      end
+
+      private
+
+      # Performs the backup creation 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
+        )
+
+        return ExitCodes::SUCCESS unless confirm_operation
+
+        results = service.create(
+          @resource_ids,
+          storage: @options[:storage],
+          mode: @options[:mode] || "snapshot",
+          compress: @options[:compress] || "zstd",
+          notes: @options[:notes],
+          protected: @options[:protected] || false
+        )
+
+        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
+
+      # Confirms multi-VMID operation with user.
+      #
+      # @return [Boolean] true if operation should proceed
+      def confirm_operation
+        return true if @resource_ids.size == 1
+        return true if @options[:yes]
+
+        $stdout.puts "You are about to create backups for #{@resource_ids.size} VMs:"
+        @resource_ids.each { |vmid| $stdout.puts "  - #{vmid}" }
+        $stdout.puts ""
+        $stdout.print "Proceed? [y/N]: "
+
+        response = $stdin.gets&.strip&.downcase
+        %w[y yes].include?(response)
+      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[:fail_fast] = true if @options[:"fail-fast"]
+        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/create_container.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Handler for the `pvectl create container` command.
+    #
+    # Includes CreateResourceCommand for shared workflow and overrides
+    # template methods with container-specific behavior.
+    #
+    # @example Flag-based creation
+    #   pvectl create container --hostname web-ct --ostemplate local:vztmpl/debian-12.tar.zst \
+    #     --rootfs storage=local-lvm,size=8G --cores 2 --memory 2048
+    #
+    class CreateContainer
+      include CreateResourceCommand
+      include SharedConfigParsers
+
+      private
+
+      # @return [String] human label for container resources
+      def resource_label
+        "container"
+      end
+
+      # @return [String] human label for container IDs
+      def resource_id_label
+        "CTID"
+      end
+
+      # @return [Boolean] true if --hostname is missing
+      def required_params_missing?
+        !@options[:hostname]
+      end
+
+      # @return [Object] container creation wizard
+      def build_wizard
+        Pvectl::Wizards::CreateContainer.new(@options, @global_options)
+      end
+
+      # @param connection [Connection] API connection
+      # @param task_repo [Repositories::Task] task repository
+      # @return [Services::CreateContainer] container creation service
+      def build_create_service(connection, task_repo)
+        ct_repo = Pvectl::Repositories::Container.new(connection)
+        Pvectl::Services::CreateContainer.new(
+          container_repository: ct_repo,
+          task_repository: task_repo,
+          options: service_options
+        )
+      end
+
+      # @param result [Models::ContainerOperationResult] operation result
+      # @return [void]
+      def output_result(result)
+        presenter = Pvectl::Presenters::ContainerOperationResult.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
+
+      # Validates flags and performs flag-based creation.
+      #
+      # @return [Integer] exit code
+      def perform_create
+        return usage_error("--hostname is required") unless @options[:hostname]
+        return usage_error("--ostemplate is required") unless @options[:ostemplate]
+        return usage_error("--rootfs is required") unless @options[:rootfs]
+
+        super
+      end
+
+      # Extracts CLI options into a service params hash.
+      #
+      # Delegates container config parsing to SharedConfigParsers#build_ct_config_params,
+      # then adds create-specific parameters.
+      #
+      # @return [Hash] service-compatible parameters
+      # @raise [ArgumentError] if parser validation fails
+      def build_params_from_flags
+        params = build_ct_config_params
+        params[:hostname] = @options[:hostname]
+        params[:node] = @options[:node] || resolve_default_node
+        params[:ostemplate] = @options[:ostemplate]
+        params[:description] = @options[:description]
+        params[:pool] = @options[:pool]
+
+        ctid = @args.first
+        params[:ctid] = ctid.to_i if ctid
+
+        params.compact
+      end
+
+      # @param params [Hash] container creation parameters
+      # @return [void]
+      def display_resource_summary(params)
+        $stdout.puts "  Hostname:  #{params[:hostname]}"
+        $stdout.puts "  Node:      #{params[:node] || '(from context)'}"
+        $stdout.puts "  Template:  #{truncate_template(params[:ostemplate])}"
+        $stdout.puts "  CPU:       #{params[:cores] || 1} cores" if params[:cores]
+        $stdout.puts "  Memory:    #{params[:memory] || 512} MB"
+        $stdout.puts "  Swap:      #{params[:swap] || 512} MB"
+
+        if params[:rootfs]
+          $stdout.puts "  Root FS:   #{params[:rootfs][:storage]}, #{params[:rootfs][:size]}"
+        end
+
+        if params[:mountpoints]
+          params[:mountpoints].each_with_index do |mp, i|
+            $stdout.puts "  Mount#{i}:    #{mp[:storage]}, #{mp[:size]} -> #{mp[:mp]}"
+          end
+        end
+
+        if params[:nets]
+          params[:nets].each_with_index do |net, i|
+            ip_info = net[:ip] ? ", #{net[:ip]}" : ""
+            $stdout.puts "  Net#{i}:      #{net[:bridge]}, #{net[:name] || 'eth0'}#{ip_info}"
+          end
+        end
+
+        $stdout.puts "  Unpriv:    #{params[:privileged] ? 'No' : 'Yes'}"
+        $stdout.puts "  Features:  #{params[:features]}" if params[:features]
+        $stdout.puts "  Tags:      #{params[:tags]}" if params[:tags]
+        $stdout.puts "  Pool:      #{params[:pool]}" if params[:pool]
+      end
+
+      # Truncates long template paths for display.
+      #
+      # @param template [String] full template path
+      # @return [String] truncated template name
+      def truncate_template(template)
+        return template unless template
+
+        parts = template.split("/")
+        parts.last || template
+      end
+    end
+  end
+end

data/lib/pvectl/commands/create_resource_command.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Commands
+    # Shared functionality for resource creation commands.
+    #
+    # Template method pattern: provides common create workflow
+    # (interactive detection, confirmation, dry-run, config loading)
+    # while specialization classes define resource-specific hooks.
+    #
+    # @abstract Include this module and implement template methods.
+    #
+    # @example Specialization
+    #   class CreateVm
+    #     include CreateResourceCommand
+    #     private
+    #     def resource_label = "VM"
+    #     def resource_id_label = "VMID"
+    #     # ...
+    #   end
+    #
+    module CreateResourceCommand
+      # Class methods added when the module is included.
+      module ClassMethods
+        # Executes the create 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 create 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 create command.
+      #
+      # @return [Integer] exit code
+      def execute
+        if interactive_mode?
+          perform_interactive
+        else
+          perform_create
+        end
+      end
+
+      private
+
+      # --- Template methods (override in specialization) ---
+
+      # @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
+
+      # @return [Boolean] true if required params for non-interactive mode are missing
+      def required_params_missing?
+        raise NotImplementedError, "#{self.class} must implement #required_params_missing?"
+      end
+
+      # @return [Hash] parameters built from CLI flags
+      def build_params_from_flags
+        raise NotImplementedError, "#{self.class} must implement #build_params_from_flags"
+      end
+
+      # @return [Object] wizard instance for interactive mode
+      def build_wizard
+        raise NotImplementedError, "#{self.class} must implement #build_wizard"
+      end
+
+      # @param connection [Connection] API connection
+      # @param task_repo [Repositories::Task] task repository
+      # @return [Object] create service instance
+      def build_create_service(connection, task_repo)
+        raise NotImplementedError, "#{self.class} must implement #build_create_service"
+      end
+
+      # @param result [Models::OperationResult] operation result
+      # @return [void]
+      def output_result(result)
+        raise NotImplementedError, "#{self.class} must implement #output_result"
+      end
+
+      # @param params [Hash] creation parameters
+      # @return [void]
+      def display_resource_summary(params)
+        raise NotImplementedError, "#{self.class} must implement #display_resource_summary"
+      end
+
+      # --- Shared implementation ---
+
+      # Determines whether to use interactive mode.
+      #
+      # @return [Boolean] true if interactive mode should be used
+      def interactive_mode?
+        return true if @options[:interactive]
+        return false if @options[:"no-interactive"]
+
+        $stdin.tty? && required_params_missing?
+      end
+
+      # Runs the interactive wizard flow.
+      #
+      # @return [Integer] exit code
+      def perform_interactive
+        wizard = build_wizard
+        wizard_params = wizard.run
+        return ExitCodes::SUCCESS unless wizard_params
+
+        @options[:start] = wizard_params.delete(:start) if wizard_params.key?(:start)
+        perform_create_with_params(wizard_params)
+      end
+
+      # Validates flags and performs flag-based creation.
+      #
+      # @return [Integer] exit code
+      def perform_create
+        params = build_params_from_flags
+        perform_create_with_params(params)
+      rescue ArgumentError => e
+        usage_error(e.message)
+      end
+
+      # Creates a resource with the given parameters.
+      #
+      # @param params [Hash] creation parameters
+      # @return [Integer] exit code
+      def perform_create_with_params(params)
+        return ExitCodes::SUCCESS if display_summary_and_confirm(params) == :cancelled
+        return ExitCodes::SUCCESS if @options[:"dry-run"]
+
+        load_config
+        connection = Pvectl::Connection.new(@config)
+        task_repo = Pvectl::Repositories::Task.new(connection)
+
+        service = build_create_service(connection, task_repo)
+        result = service.execute(**params)
+        output_result(result)
+        result.failed? ? ExitCodes::GENERAL_ERROR : ExitCodes::SUCCESS
+      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
+
+      # Displays a creation summary and prompts for confirmation.
+      #
+      # @param params [Hash] creation parameters
+      # @return [Symbol, nil] +:cancelled+ if user declines, +nil+ otherwise
+      def display_summary_and_confirm(params)
+        display_summary(params)
+
+        return nil if @options[:yes]
+
+        $stdout.print "Create this #{resource_label}? [y/N] "
+        $stdout.flush
+        answer = $stdin.gets&.strip&.downcase
+        answer == "y" ? nil : :cancelled
+      end
+
+      # Displays the creation summary.
+      #
+      # @param params [Hash] creation parameters
+      # @return [void]
+      def display_summary(params)
+        $stdout.puts ""
+        $stdout.puts "  Create #{resource_label} - Summary"
+        $stdout.puts "  #{'─' * 40}"
+        $stdout.puts "  #{resource_id_label}:#{' ' * (10 - resource_id_label.length)}#{params[:vmid] || params[:ctid] || '(auto)'}"
+        display_resource_summary(params)
+        $stdout.puts "  #{'─' * 40}"
+        $stdout.puts "  (dry-run mode -- no #{resource_label} will be created)" if @options[:"dry-run"]
+        $stdout.puts ""
+      end
+
+      # Resolves the default node from configuration.
+      #
+      # @return [String, nil] default node name or nil
+      def resolve_default_node
+        load_config unless @config
+        @config&.default_node
+      rescue StandardError
+        nil
+      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[:start] = true if @options[:start]
+        opts
+      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