durable-proxmox-ruby 0.1.0

data/exe/proxmox

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Only require bundler/setup when not running as a packaged tebako executable
+# Check if we're running from the tebako memfs
+unless $LOAD_PATH.first&.start_with?('/__tebako_memfs__')
+  require "bundler/setup"
+end
+
+require "durable_proxmox"
+require "optparse"
+
+class ProxmoxCLI
+  def initialize
+    @options = {}
+    @parser = create_parser
+  end
+
+  def run(args)
+    @parser.parse!(args)
+    command = args.shift
+
+    case command
+    when "nodes"
+      list_nodes
+    when "vms"
+      list_vms(args.shift)
+    when "start"
+      start_vm(args)
+    when "stop"
+      stop_vm(args)
+    when "delete"
+      delete_vm(args)
+    when "spawn"
+      spawn_vm(args)
+    when "ips"
+      show_ips(args)
+    when "export"
+      export_dsl(args)
+    when "version"
+      puts "durable-proxmox-ruby v#{DurableProxmox::VERSION}"
+    else
+      puts @parser.help
+      exit 1
+    end
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    puts e.backtrace if @options[:debug]
+    exit 1
+  end
+
+  private
+
+  def create_parser
+    OptionParser.new do |opts|
+      opts.banner = "Usage: proxmox [options] COMMAND [args]"
+      opts.separator ""
+      opts.separator "Commands:"
+      opts.separator "  nodes                  List all Proxmox nodes"
+      opts.separator "  vms [NODE]             List VMs (optionally filter by node name)"
+      opts.separator "  start NODE VMID        Start a VM"
+      opts.separator "  stop NODE VMID         Stop a VM"
+      opts.separator "  delete NODE VMID       Delete a VM"
+      opts.separator "  spawn NODE HOSTNAME    Spawn a new VM from template"
+      opts.separator "  ips NODE VMID          Show IP addresses for a VM"
+      opts.separator "  export [NODE] [FILE]   Export infrastructure as DSL script"
+      opts.separator "  version                Show version"
+      opts.separator ""
+      opts.separator "Options:"
+
+      opts.on("-d", "--debug", "Enable debug mode") do
+        @options[:debug] = true
+      end
+
+      opts.on("--insecure", "Skip SSL certificate validation and expiry checks") do
+        @options[:insecure] = true
+      end
+
+      opts.on("-h", "--help", "Show this help message") do
+        puts opts
+        exit
+      end
+    end
+  end
+
+  def client
+    @client ||= DurableProxmox.client(nil, insecure: @options[:insecure])
+  end
+
+  def list_nodes
+    nodes = client.nodes
+    puts "Nodes:"
+    nodes.each do |node|
+      puts "  #{node.node_id} (#{node.status}) - CPU: #{(node.cpu * 100).round(2)}%, Memory: #{node.memory}"
+    end
+  end
+
+  def list_vms(node_filter = nil)
+    nodes = client.nodes
+    nodes = nodes.select { |n| n.node_id == node_filter } if node_filter
+
+    nodes.each do |node|
+      puts "Node: #{node.node_id}"
+      vms = node.vms
+      if vms.empty?
+        puts "  No VMs"
+      else
+        vms.each do |vm|
+          puts "  [#{vm.vm_id}] #{vm.name} (#{vm.status})"
+        end
+      end
+      puts
+    end
+  end
+
+  def find_vm(node_name, vmid)
+    node = client.nodes.find { |n| n.node_id == node_name }
+    raise "Node '#{node_name}' not found" unless node
+
+    vm = node.vms.find { |v| v.vm_id.to_s == vmid.to_s }
+    raise "VM '#{vmid}' not found on node '#{node_name}'" unless vm
+
+    [node, vm]
+  end
+
+  def start_vm(args)
+    raise "Usage: proxmox start NODE VMID" if args.length < 2
+
+    node_name, vmid = args
+    _node, vm = find_vm(node_name, vmid)
+
+    puts "Starting VM #{vmid} on node #{node_name}..."
+    vm.start
+    puts "VM started successfully"
+  end
+
+  def stop_vm(args)
+    raise "Usage: proxmox stop NODE VMID" if args.length < 2
+
+    node_name, vmid = args
+    _node, vm = find_vm(node_name, vmid)
+
+    puts "Stopping VM #{vmid} on node #{node_name}..."
+    vm.stop
+    puts "VM stopped successfully"
+  end
+
+  def delete_vm(args)
+    raise "Usage: proxmox delete NODE VMID" if args.length < 2
+
+    node_name, vmid = args
+    node, vm = find_vm(node_name, vmid)
+
+    puts "Deleting VM #{vmid} on node #{node_name}..."
+    node.delete_vm(vm)
+    puts "VM deleted successfully"
+  end
+
+  def spawn_vm(args)
+    raise "Usage: proxmox spawn NODE HOSTNAME" if args.length < 2
+
+    node_name, hostname = args
+    node = client.nodes.find { |n| n.node_id == node_name }
+    raise "Node '#{node_name}' not found" unless node
+
+    puts "Spawning VM '#{hostname}' on node #{node_name}..."
+    new_vmid = node.spawn_vm(hostname)
+    puts "VM spawned successfully with ID: #{new_vmid}"
+  end
+
+  def show_ips(args)
+    raise "Usage: proxmox ips NODE VMID" if args.length < 2
+
+    node_name, vmid = args
+    _node, vm = find_vm(node_name, vmid)
+
+    puts "IP addresses for VM #{vmid} (#{vm.name}):"
+    vm.network_interfaces.each do |iface|
+      next if iface["name"] == "lo"
+
+      puts "  Interface: #{iface['name']}"
+      if iface["ip-addresses"]
+        iface["ip-addresses"].each do |ip|
+          puts "    #{ip['ip-address']}/#{ip['prefix']}"
+        end
+      end
+    end
+  end
+
+  def export_dsl(args)
+    node_filter = args.shift
+    output_file = args.shift
+
+    # Find the node if specified
+    target_node = nil
+    if node_filter
+      target_node = client.nodes.find { |n| n.node_id == node_filter }
+      raise "Node '#{node_filter}' not found" unless target_node
+      puts "Exporting configuration for node: #{node_filter}..."
+    else
+      puts "Exporting configuration for all nodes..."
+    end
+
+    # Generate the DSL script
+    script = client.export_configuration(target_node)
+
+    # Output to file or stdout
+    if output_file
+      File.write(output_file, script)
+      puts "Configuration exported to: #{output_file}"
+      puts "To apply: ruby #{output_file}"
+    else
+      puts script
+    end
+  end
+end
+
+ProxmoxCLI.new.run(ARGV)

data/lib/durable_proxmox/client.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module DurableProxmox
+  # Main client for interacting with Proxmox API.
+  #
+  # Handles authentication, HTTP requests, and provides access to nodes and VMs.
+  class Client
+    # @return [String] The base URL for the Proxmox API
+    attr_reader :url_base
+
+    # @return [Faraday::Connection] The HTTP connection
+    attr_reader :connection
+
+    # @return [Hash] Authentication parameters
+    attr_reader :auth_params
+
+    # Creates a new Proxmox client with automatic authentication.
+    #
+    # @param url_base [String, nil] The base URL for the Proxmox API.
+    #   Defaults to ENV['PROXMOX_HOSTNAME'] or a default URL.
+    # @param insecure [Boolean] Skip SSL certificate validation and expiry checks (default: false).
+    #   Set to true for self-signed or expired certificates.
+    def initialize(url_base = nil, insecure: false)
+      hostname = ENV['PROXMOX_HOSTNAME'] || 'fuzzyfireball.durablelan'
+      @url_base = url_base || "https://#{hostname}:8006/api2/json/"
+      @insecure = insecure
+
+      @connection = create_connection
+      @auth_params = create_auth_header
+    end
+
+    # Creates a new Faraday connection with appropriate SSL settings.
+    #
+    # @return [Faraday::Connection] A new connection instance
+    def create_connection
+      ssl_options = if @insecure
+                      {
+                        verify: false,
+                        version: :TLSv1_2
+                      }
+                    else
+                      { verify: true }
+                    end
+
+      Faraday.new(@url_base, headers: { "user_agent": 'DurableProxmox - As Suave As They Come', "Accept-Encoding": 'identity' }, ssl: ssl_options) do |f|
+        f.request :url_encoded
+        f.response :json, content_type: /\bjson$/
+        f.adapter :net_http do |client|
+          client.keep_alive_timeout = 5
+          client.read_timeout = 60
+          client.write_timeout = 60
+        end
+      end
+    end
+
+    # Creates an authentication header for API token access.
+    #
+    # @return [Hash] Authentication parameters with Authorization header
+    # @raise [RuntimeError] If required environment variables are missing
+    def create_auth_header
+      username = ENV['PROXMOX_USERNAME']
+      token_name = ENV['PROXMOX_API_TOKEN_NAME']
+      token_secret = ENV['PROXMOX_API_TOKEN_SECRET']
+
+      raise AuthenticationError, 'PROXMOX_USERNAME environment variable is required' unless username
+      raise AuthenticationError, 'PROXMOX_API_TOKEN_NAME environment variable is required' unless token_name
+      raise AuthenticationError, 'PROXMOX_API_TOKEN_SECRET environment variable is required' unless token_secret
+
+      token = "#{username}!#{token_name}=#{token_secret}"
+      {
+        'Authorization' => "PVEAPIToken=#{token}"
+      }
+    end
+
+    # Performs an authenticated POST request.
+    #
+    # @param path [String] The API endpoint path
+    # @param params [Hash] Request parameters
+    # @return [Faraday::Response] The response
+    def post(path, params = {})
+      @connection.post(path, params) do |req|
+        req.headers.merge!(@auth_params)
+      end
+    end
+
+    # Performs an authenticated DELETE request.
+    #
+    # @param path [String] The API endpoint path
+    # @param params [Hash] Request parameters
+    # @return [Faraday::Response] The response
+    def delete(path, params = {})
+      @connection.delete(path, params) do |req|
+        req.headers.merge!(@auth_params)
+      end
+    end
+
+    # Performs an authenticated GET request.
+    #
+    # @param path [String] The API endpoint path
+    # @param params [Hash] Request parameters
+    # @return [Faraday::Response] The response
+    def get(path, params = {})
+      retries = 0
+      max_retries = 3
+      begin
+        # Create a new connection for each request to avoid connection reuse issues
+        conn = create_connection
+        conn.get(path, params) do |req|
+          req.headers.merge!(@auth_params)
+        end
+      rescue EOFError, OpenSSL::SSL::SSLError, Faraday::ConnectionFailed, Faraday::SSLError => e
+        retries += 1
+        $stderr.puts "Request failed (attempt #{retries}/#{max_retries}): #{e.class} - #{e.message}" if ENV['DEBUG']
+        if retries <= max_retries
+          sleep 0.5
+          retry
+        else
+          raise
+        end
+      end
+    end
+
+    # Retrieves all nodes from the Proxmox cluster.
+    #
+    # @return [Array<DurableProxmox::Node>] Array of node objects
+    def nodes
+      get('nodes').body['data'].map { |data| Node.new(data, self) }
+    end
+
+    # Waits for an asynchronous Proxmox task to complete.
+    #
+    # @param node_or_node_id [DurableProxmox::Node, String] The node or node ID
+    # @param upid [String] The task UPID
+    # @param show_progress [Boolean] Show a progress bar while waiting (default: true)
+    def wait_for_upid(node_or_node_id, upid, show_progress: true)
+      node_id = node_or_node_id.respond_to?(:node_id) ? node_or_node_id.node_id : node_or_node_id
+      elapsed = 0
+
+      if show_progress
+        print "Waiting for task to complete "
+      end
+
+      loop do
+        task_status = get("nodes/#{node_id}/tasks/#{upid}/status").body
+        status = task_status.dig('data', 'status')
+        break unless status == 'running'
+
+        if show_progress
+          print "."
+          $stdout.flush
+        end
+
+        sleep 1
+        elapsed += 1
+      end
+
+      if show_progress
+        puts " done (#{elapsed}s)"
+      end
+
+      # Check if task succeeded or failed
+      task_status = get("nodes/#{node_id}/tasks/#{upid}/status").body
+      exitstatus = task_status.dig('data', 'exitstatus')
+
+      if exitstatus && exitstatus != 'OK'
+        $stderr.puts "Warning: Task completed with status: #{exitstatus}"
+      end
+    end
+
+    # Exports the current Proxmox infrastructure as a DSL script.
+    #
+    # @param node [DurableProxmox::Node, nil] Optional specific node to export (exports all if nil)
+    # @param options [Hash] Export options
+    # @option options [Boolean] :include_stopped Include stopped VMs (default: true)
+    # @option options [Boolean] :include_templates Include template VMs (default: false)
+    # @return [String] The generated DSL script
+    def export_configuration(node = nil, options = {})
+      include_stopped = options.fetch(:include_stopped, true)
+      include_templates = options.fetch(:include_templates, false)
+
+      target_nodes = node ? [node] : nodes
+
+      script_lines = []
+      script_lines << '#!/usr/bin/env ruby'
+      script_lines << '# frozen_string_literal: true'
+      script_lines << ''
+      script_lines << "# Generated by durable-proxmox-ruby on #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+      script_lines << '# This script defines the current Proxmox infrastructure'
+      script_lines << ''
+      script_lines << "require 'durable_proxmox'"
+      script_lines << ''
+      script_lines << '# Apply this configuration with: ruby <filename>.rb'
+      script_lines << ''
+      script_lines << 'DurableProxmox::DSL.configure do'
+
+      target_nodes.each do |target_node|
+        vms = target_node.vms
+
+        # Filter VMs based on options
+        vms = vms.reject { |vm| vm.status == 'stopped' } unless include_stopped
+        vms = vms.reject { |vm| vm.data['template'] == 1 } unless include_templates
+
+        vms.each do |vm|
+          script_lines << generate_vm_dsl(vm, target_node)
+        end
+      end
+
+      script_lines << 'end.apply'
+      script_lines << ''
+
+      script_lines.join("\n")
+    end
+
+    private
+
+    # Generates DSL code for a single VM.
+    #
+    # @param vm [DurableProxmox::VM] The VM to export
+    # @param node [DurableProxmox::Node] The node the VM is on
+    # @return [String] The DSL code for the VM
+    def generate_vm_dsl(vm, node)
+      config = vm.config
+      lines = []
+
+      lines << ''
+      lines << "  # Node: #{node.node_id}"
+      lines << "  # Status: #{vm.status}"
+      lines << "  vm '#{vm.name}' do"
+      lines << "    vmid #{vm.vm_id}"
+
+      # Extract cores
+      lines << "    cores #{config['cores']}" if config['cores']
+
+      # Extract memory (convert from bytes to MB if needed)
+      if config['memory']
+        memory_mb = config['memory']
+        lines << "    memory #{memory_mb}"
+      end
+
+      # Extract IP address if available
+      begin
+        ips = vm.ip_addresses
+        if ips && !ips.octets.empty?
+          primary_ip = ips.octets.first
+          lines << "    ip '#{primary_ip}'" if primary_ip
+        end
+      rescue StandardError
+        # IP address may not be available, skip
+      end
+
+      # Note about template
+      lines << '    # This is a template VM' if config['template'] == 1
+
+      lines << '  end'
+
+      lines.join("\n")
+    end
+  end
+end