pvectl 0.2.0

data/lib/pvectl/services/wakeonlan.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Sends a Wake-on-LAN packet to a cluster node.
+    #
+    # Verifies the node exists in the cluster, calls the WoL API endpoint,
+    # and wraps the outcome in a NodeOperationResult. The Proxmox API
+    # returns the MAC address used for the magic packet on success, which
+    # is surfaced in the result message for confirmation.
+    #
+    # @example Basic usage
+    #   service = Wakeonlan.new(node_repository: repo)
+    #   result = service.execute(node_name: "pve3")
+    #   result.successful? #=> true
+    #   result.message     #=> "Wake-on-LAN packet sent (MAC: AA:BB:CC:DD:EE:FF)"
+    #
+    # @see Pvectl::Repositories::Node#wakeonlan API call
+    # @see Pvectl::Models::NodeOperationResult Returned result wrapper
+    #
+    class Wakeonlan
+      # Creates a new service.
+      #
+      # @param node_repository [Repositories::Node] Node repository (DI)
+      def initialize(node_repository:)
+        @node_repository = node_repository
+      end
+
+      # Sends the WoL packet to a node.
+      #
+      # @param node_name [String] target node name
+      # @return [Models::NodeOperationResult] outcome (success/failure)
+      def execute(node_name:)
+        node = @node_repository.get(node_name)
+        return not_found_result(node_name) unless node
+
+        mac = @node_repository.wakeonlan(node_name)
+        build_result(node, success: true, message: success_message(mac))
+      rescue StandardError => e
+        build_result(node || Models::Node.new(name: node_name), success: false, error: e.message)
+      end
+
+      private
+
+      # Builds a NodeOperationResult.
+      #
+      # @param node [Models::Node] target node
+      # @param attrs [Hash] additional attributes (:success, :error, :message)
+      # @return [Models::NodeOperationResult]
+      def build_result(node, **attrs)
+        Models::NodeOperationResult.new(
+          operation: :wakeonlan,
+          node_model: node,
+          resource: { node_name: node.name },
+          **attrs
+        )
+      end
+
+      # Builds a not-found error result.
+      #
+      # @param node_name [String]
+      # @return [Models::NodeOperationResult]
+      def not_found_result(node_name)
+        node = Models::Node.new(name: node_name)
+        build_result(node, success: false, error: "Node #{node_name} not found")
+      end
+
+      # Formats the success message including the MAC address when returned.
+      #
+      # @param mac [String, nil]
+      # @return [String]
+      def success_message(mac)
+        return "Wake-on-LAN packet sent" if mac.nil? || mac.to_s.empty?
+
+        "Wake-on-LAN packet sent (MAC: #{mac})"
+      end
+    end
+  end
+end

data/lib/pvectl/utils/resource_resolver.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Utils
+    # Utility for resolving VMID to VM/container type and node.
+    #
+    # ResourceResolver auto-detects whether a given VMID belongs to a
+    # QEMU virtual machine or LXC container and retrieves its node location.
+    # Results are cached for efficiency when resolving multiple VMIDs.
+    #
+    # @example Resolving a single VMID
+    #   resolver = ResourceResolver.new(connection)
+    #   info = resolver.resolve(100)
+    #   puts "VM #{info[:vmid]} is a #{info[:type]} on #{info[:node]}"
+    #
+    # @example Resolving multiple VMIDs
+    #   resolver = ResourceResolver.new(connection)
+    #   infos = resolver.resolve_multiple([100, 101, 102])
+    #   infos.each { |i| puts "#{i[:vmid]}: #{i[:type]}" }
+    #
+    class ResourceResolver
+      # Creates a new ResourceResolver.
+      #
+      # @param connection [Connection] Proxmox API connection
+      def initialize(connection)
+        @connection = connection
+        @cache = nil
+      end
+
+      # Resolves a VMID to its resource information.
+      #
+      # @param vmid [Integer, String] VM or container identifier
+      # @return [Hash, nil] hash with :vmid, :node, :type (:qemu or :lxc), :name
+      #   or nil if not found
+      def resolve(vmid)
+        vmid = vmid.to_i
+        load_resources
+        @cache[vmid]
+      end
+
+      # Resolves multiple VMIDs to their resource information.
+      #
+      # @param vmids [Array<Integer, String>] array of VM/container identifiers
+      # @return [Array<Hash>] array of resolved resources (unknown VMIDs are skipped)
+      def resolve_multiple(vmids)
+        load_resources
+        vmids.map { |id| @cache[id.to_i] }.compact
+      end
+
+      # Returns all resources in the cluster.
+      #
+      # @return [Array<Hash>] array of all VM/container resources
+      def resolve_all
+        load_resources
+        @cache.values
+      end
+
+      private
+
+      # Loads and caches cluster resources.
+      #
+      # @return [void]
+      def load_resources
+        return if @cache
+
+        response = @connection.client["cluster/resources"].get(type: "vm")
+        @cache = {}
+
+        response.each do |r|
+          @cache[r[:vmid]] = {
+            vmid: r[:vmid],
+            node: r[:node],
+            type: r[:type] == "lxc" ? :lxc : :qemu,
+            name: r[:name]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pvectl
+  # Current version of the pvectl gem.
+  #
+  # Versioning follows Semantic Versioning (https://semver.org/):
+  # - MAJOR: breaking changes
+  # - MINOR: new features, backwards compatible
+  # - PATCH: bug fixes, backwards compatible
+  #
+  # @return [String] version number in MAJOR.MINOR.PATCH format
+  VERSION = "0.2.0"
+end

data/lib/pvectl/wizards/create_container.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Wizards
+    # Interactive wizard for creating an LXC container step by step.
+    #
+    # Uses TTY::Prompt (when available) or a fallback prompt to guide the user
+    # through container configuration. Returns a normalized params hash compatible
+    # with Services::CreateContainer, or nil if the user cancels.
+    #
+    # @example Running the wizard
+    #   wizard = CreateContainer.new(options, global_options)
+    #   params = wizard.run
+    #   #=> { hostname: "web-ct", node: "pve1", ... } or nil
+    #
+    class CreateContainer
+      # Creates a new CreateContainer wizard.
+      #
+      # @param options [Hash] command options (may contain pre-filled values)
+      # @param global_options [Hash] global CLI options
+      # @param prompt [Object] prompt instance (injectable for testing)
+      def initialize(options, global_options, prompt: nil)
+        @options = options
+        @global_options = global_options
+        @prompt = prompt || create_default_prompt
+      end
+
+      # Runs the wizard and returns params or nil if cancelled.
+      #
+      # @return [Hash, nil] creation params or nil if user cancels
+      def run
+        collect_params
+      end
+
+      private
+
+      # Creates a default prompt, preferring TTY::Prompt with SimplePrompt fallback.
+      #
+      # @return [Object] prompt object
+      def create_default_prompt
+        require "tty-prompt"
+        TTY::Prompt.new
+      rescue LoadError
+        Config::SimplePrompt.new
+      end
+
+      # Collects all parameters interactively.
+      #
+      # @return [Hash] collected parameters
+      def collect_params
+        params = {}
+        params[:hostname] = @prompt.ask("Container hostname:", required: true)
+        params[:ostemplate] = @prompt.ask("OS template path:", required: true)
+        params[:node] = @prompt.ask("Node:", default: @options[:node])
+        params[:cores] = @prompt.ask("CPU cores:", default: 1, convert: :int)
+        params[:memory] = @prompt.ask("Memory (MB):", default: 512, convert: :int)
+        params[:swap] = @prompt.ask("Swap (MB):", default: 512, convert: :int)
+        params[:rootfs] = collect_rootfs
+        params[:mountpoints] = collect_mountpoints
+        params[:nets] = collect_nets
+        params[:privileged] = true unless @prompt.yes?("Unprivileged container?", default: true)
+        params[:start] = true if @prompt.yes?("Start container after creation?")
+        params.compact
+      end
+
+      # Collects root filesystem configuration.
+      #
+      # @return [Hash] parsed rootfs config
+      def collect_rootfs
+        input = @prompt.ask("Root FS (storage=X,size=Y):", required: true)
+        Parsers::LxcMountConfig.parse(input)
+      end
+
+      # Collects mountpoint configurations interactively.
+      #
+      # @return [Array<Hash>, nil] mountpoint configs or nil if none added
+      def collect_mountpoints
+        mps = []
+        loop do
+          input = @prompt.ask("Mountpoint (mp=/path,storage=X,size=Y) or empty to skip:")
+          break if input.nil? || input.empty?
+
+          mps << Parsers::LxcMountConfig.parse(input)
+          break unless @prompt.yes?("Add another mountpoint?")
+        end
+        mps.empty? ? nil : mps
+      end
+
+      # Collects network configurations interactively.
+      #
+      # @return [Array<Hash>, nil] net configs or nil if none added
+      def collect_nets
+        nets = []
+        loop do
+          input = @prompt.ask("Network config (bridge=X[,ip=Y]) or empty to skip:")
+          break if input.nil? || input.empty?
+
+          nets << Parsers::LxcNetConfig.parse(input)
+          break unless @prompt.yes?("Add another network?")
+        end
+        nets.empty? ? nil : nets
+      end
+    end
+  end
+end

data/lib/pvectl/wizards/create_vm.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Wizards
+    # Interactive wizard for creating a VM step by step.
+    #
+    # Uses TTY::Prompt (when available) or a fallback prompt to guide the user
+    # through VM configuration. Returns a normalized params hash compatible
+    # with Services::CreateVm, or nil if the user cancels.
+    #
+    # @example Running the wizard
+    #   wizard = CreateVm.new(options, global_options)
+    #   params = wizard.run
+    #   #=> { name: "web", node: "pve1", cores: 4, ... } or nil
+    #
+    class CreateVm
+      OS_TYPES = %w[l26 l24 win11 win10 win2k22 win2k19 win2k16 win8 win7 other].freeze
+
+      # Creates a new CreateVm wizard.
+      #
+      # @param options [Hash] command options (may contain pre-filled values)
+      # @param global_options [Hash] global CLI options
+      # @param prompt [Object] prompt instance (injectable for testing)
+      def initialize(options, global_options, prompt: nil)
+        @options = options
+        @global_options = global_options
+        @prompt = prompt || create_default_prompt
+      end
+
+      # Runs the wizard and returns params or nil if cancelled.
+      #
+      # @return [Hash, nil] creation params or nil if user cancels
+      def run
+        collect_params
+      end
+
+      private
+
+      # Creates a default prompt, preferring TTY::Prompt with SimplePrompt fallback.
+      #
+      # @return [Object] prompt object
+      def create_default_prompt
+        require "tty-prompt"
+        TTY::Prompt.new
+      rescue LoadError
+        Config::SimplePrompt.new
+      end
+
+      # Collects all parameters interactively.
+      #
+      # @return [Hash] collected parameters
+      def collect_params
+        params = {}
+        params[:name] = @prompt.ask("VM name:", required: true)
+        params[:node] = @prompt.ask("Node:", default: @options[:node])
+        params[:cores] = @prompt.ask("CPU cores:", default: 1, convert: :int)
+        params[:sockets] = @prompt.ask("CPU sockets:", default: 1, convert: :int)
+        params[:memory] = @prompt.ask("Memory (MB):", default: 2048, convert: :int)
+        params[:disks] = collect_disks
+        params[:nets] = collect_nets
+        params[:ostype] = @prompt.select("OS type:", OS_TYPES)
+        params[:agent] = true if @prompt.yes?("Enable QEMU guest agent?")
+        params[:start] = true if @prompt.yes?("Start VM after creation?")
+        params.compact
+      end
+
+      # Collects disk configurations interactively.
+      #
+      # @return [Array<Hash>, nil] disk configs or nil if none added
+      def collect_disks
+        disks = []
+        loop do
+          input = @prompt.ask("Disk config (storage=X,size=Y) or empty to skip:")
+          break if input.nil? || input.empty?
+
+          disks << Parsers::DiskConfig.parse(input)
+          break unless @prompt.yes?("Add another disk?")
+        end
+        disks.empty? ? nil : disks
+      end
+
+      # Collects network configurations interactively.
+      #
+      # @return [Array<Hash>, nil] net configs or nil if none added
+      def collect_nets
+        nets = []
+        loop do
+          input = @prompt.ask("Network config (bridge=X) or empty to skip:")
+          break if input.nil? || input.empty?
+
+          nets << Parsers::NetConfig.parse(input)
+          break unless @prompt.yes?("Add another network?")
+        end
+        nets.empty? ? nil : nets
+      end
+    end
+  end
+end