pvectl 0.2.0

data/lib/pvectl/config/provider.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Pvectl
+  module Config
+    # Loads and resolves configuration from multiple sources.
+    #
+    # Provider handles loading configuration from YAML files and environment
+    # variables, then merging them with proper priority to produce a final
+    # ResolvedConfig. Priority order (highest to lowest):
+    # 1. CLI options
+    # 2. Environment variables
+    # 3. Configuration file
+    #
+    # @example Loading configuration
+    #   provider = Provider.new
+    #   config = provider.resolve(
+    #     config_path: "~/.pvectl/config",
+    #     cli_options: { context: "production" }
+    #   )
+    #
+    class Provider
+      # Mapping of environment variables to configuration keys
+      ENV_VARS = {
+        "PROXMOX_HOST" => :server,
+        "PROXMOX_TOKEN_ID" => :token_id,
+        "PROXMOX_TOKEN_SECRET" => :token_secret,
+        "PROXMOX_USER" => :username,
+        "PROXMOX_PASSWORD" => :password,
+        "PROXMOX_VERIFY_SSL" => :verify_ssl,
+        "PVECTL_CONTEXT" => :context,
+        "PVECTL_CONFIG" => :config_path,
+        # Retry/timeout settings
+        "PROXMOX_TIMEOUT" => :timeout,
+        "PROXMOX_RETRY_COUNT" => :retry_count,
+        "PROXMOX_RETRY_DELAY" => :retry_delay,
+        "PROXMOX_MAX_RETRY_DELAY" => :max_retry_delay,
+        "PROXMOX_RETRY_WRITES" => :retry_writes
+      }.freeze
+
+      # Keys that should be parsed as integers
+      INTEGER_VARS = %i[timeout retry_count retry_delay max_retry_delay].freeze
+
+      # Keys that should be parsed as booleans
+      BOOLEAN_VARS = %i[verify_ssl retry_writes].freeze
+
+      # Checks if a configuration file exists at the given path.
+      #
+      # @param path [String] path to configuration file
+      # @return [Boolean] true if file exists
+      def file_exists?(path)
+        File.exist?(path)
+      end
+
+      # Checks if a file has insecure permissions (readable by group/others).
+      #
+      # @param path [String] path to file
+      # @return [Boolean] true if permissions are insecure
+      def insecure_permissions?(path)
+        return false unless File.exist?(path)
+
+        mode = File.stat(path).mode & 0o777
+        (mode & 0o077) != 0
+      end
+
+      # Loads configuration from a YAML file.
+      #
+      # @param path [String] path to configuration file
+      # @return [Hash] parsed configuration hash
+      # @raise [ConfigNotFoundError] if file does not exist
+      # @raise [InvalidConfigError] if YAML is invalid
+      def load_file(path)
+        raise ConfigNotFoundError, "Configuration file not found: #{path}" unless File.exist?(path)
+
+        content = File.read(path)
+        YAML.safe_load(content, permitted_classes: [Symbol])
+      rescue Psych::SyntaxError => e
+        raise InvalidConfigError, "Invalid YAML in #{path}: #{e.message}"
+      end
+
+      # Loads configuration from environment variables.
+      #
+      # @return [Hash] configuration values from environment
+      # @raise [InvalidConfigError] if integer values are invalid
+      def load_env
+        result = {}
+
+        ENV_VARS.each do |env_var, config_key|
+          value = ENV[env_var]
+          next if value.nil? || value.empty?
+
+          result[config_key] = parse_env_value(config_key, value)
+        end
+
+        result
+      end
+
+      # Resolves the context name from various sources.
+      #
+      # Priority: CLI > ENV > file
+      #
+      # @param cli_options [Hash] CLI options (may contain :context)
+      # @param file_config [Hash] configuration from file (may contain "current-context")
+      # @return [String, nil] resolved context name
+      def resolve_context_name(cli_options:, file_config: {})
+        cli_options[:context] || ENV["PVECTL_CONTEXT"] || file_config["current-context"]
+      end
+
+      # Resolves full configuration by merging all sources.
+      #
+      # @param config_path [String] path to configuration file
+      # @param cli_options [Hash] CLI options
+      # @param cluster_override [String, nil] for testing invalid cluster references
+      # @return [Models::ResolvedConfig] resolved configuration
+      # @raise [ConfigNotFoundError] if config file not found
+      # @raise [ContextNotFoundError] if context not found
+      # @raise [ClusterNotFoundError] if cluster not found
+      # @raise [UserNotFoundError] if user not found
+      def resolve(config_path:, cli_options:, cluster_override: nil)
+        file_config = load_file(config_path)
+        env_config = load_env
+
+        context_name = resolve_context_name(cli_options: cli_options, file_config: file_config)
+        context = find_context(file_config, context_name)
+
+        cluster_name = cluster_override || context.cluster_ref
+        cluster = find_cluster(file_config, cluster_name)
+        user = find_user(file_config, context.user_ref)
+
+        build_resolved_config(
+          context: context,
+          cluster: cluster,
+          user: user,
+          env_config: env_config,
+          cli_options: cli_options
+        )
+      end
+
+      private
+
+      # Parses an environment variable value to the appropriate type.
+      #
+      # @param key [Symbol] configuration key
+      # @param value [String] raw environment variable value
+      # @return [Object] parsed value (Integer, Boolean, or String)
+      # @raise [InvalidConfigError] if value cannot be parsed
+      def parse_env_value(key, value)
+        if BOOLEAN_VARS.include?(key)
+          parse_boolean_env(value)
+        elsif INTEGER_VARS.include?(key)
+          parse_integer_env(key, value)
+        else
+          value
+        end
+      end
+
+      # Parses a boolean environment variable.
+      #
+      # @param value [String] raw value
+      # @return [Boolean] parsed boolean
+      def parse_boolean_env(value)
+        %w[true 1 yes].include?(value.to_s.downcase)
+      end
+
+      # Parses an integer environment variable with validation.
+      #
+      # @param key [Symbol] configuration key (for error messages)
+      # @param value [String] raw environment variable value
+      # @return [Integer] parsed integer value
+      # @raise [InvalidConfigError] if value is not a valid non-negative integer
+      def parse_integer_env(key, value)
+        unless value.to_s.match?(/\A\d+\z/)
+          raise InvalidConfigError,
+                "Invalid integer for #{key.to_s.tr('_', '-')}: '#{value}' " \
+                "(must be a non-negative integer)"
+        end
+
+        value.to_i
+      end
+
+      # Finds a context by name in the configuration.
+      #
+      # @param config [Hash] configuration hash
+      # @param name [String] context name
+      # @return [Models::Context] context model
+      # @raise [ContextNotFoundError] if context not found
+      def find_context(config, name)
+        contexts = config["contexts"] || []
+        context_hash = contexts.find { |c| c["name"] == name }
+
+        if context_hash.nil?
+          available = contexts.map { |c| c["name"] }.join(", ")
+          raise ContextNotFoundError, "Context '#{name}' not found. Available: #{available}"
+        end
+
+        Models::Context.from_hash(context_hash)
+      end
+
+      # Finds a cluster by name in the configuration.
+      #
+      # @param config [Hash] configuration hash
+      # @param name [String] cluster name
+      # @return [Models::Cluster] cluster model
+      # @raise [ClusterNotFoundError] if cluster not found
+      def find_cluster(config, name)
+        clusters = config["clusters"] || []
+        cluster_hash = clusters.find { |c| c["name"] == name }
+
+        raise ClusterNotFoundError, "Cluster '#{name}' not found in configuration" if cluster_hash.nil?
+
+        Models::Cluster.from_hash(cluster_hash)
+      end
+
+      # Finds a user by name in the configuration.
+      #
+      # @param config [Hash] configuration hash
+      # @param name [String] user name
+      # @return [Models::User] user model
+      # @raise [UserNotFoundError] if user not found
+      def find_user(config, name)
+        users = config["users"] || []
+        user_hash = users.find { |u| u["name"] == name }
+
+        raise UserNotFoundError, "User '#{name}' not found in configuration" if user_hash.nil?
+
+        Models::User.from_hash(user_hash)
+      end
+
+      # Builds a ResolvedConfig from merged sources.
+      #
+      # @param context [Models::Context] resolved context
+      # @param cluster [Models::Cluster] resolved cluster
+      # @param user [Models::User] resolved user
+      # @param env_config [Hash] environment configuration
+      # @param cli_options [Hash] CLI options
+      # @return [Models::ResolvedConfig] resolved configuration
+      def build_resolved_config(context:, cluster:, user:, env_config:, cli_options:)
+        # Merge with priority: CLI > ENV > file
+        server = env_config[:server] || cluster.server
+        verify_ssl = env_config.key?(:verify_ssl) ? env_config[:verify_ssl] : cluster.verify_ssl
+
+        # Determine auth type and credentials
+        auth_type, token_id, token_secret, username, password = resolve_auth(user, env_config)
+
+        # Resolve retry/timeout settings with priority: ENV > file
+        timeout = env_config[:timeout] || cluster.timeout
+        retry_count = env_config[:retry_count] || cluster.retry_count
+        retry_delay = env_config[:retry_delay] || cluster.retry_delay
+        max_retry_delay = env_config[:max_retry_delay] || cluster.max_retry_delay
+        retry_writes = env_config.key?(:retry_writes) ? env_config[:retry_writes] : cluster.retry_writes
+
+        Models::ResolvedConfig.new(
+          context_name: context.name,
+          server: server,
+          verify_ssl: verify_ssl,
+          certificate_authority: cluster.certificate_authority,
+          auth_type: auth_type,
+          token_id: token_id,
+          token_secret: token_secret,
+          username: username,
+          password: password,
+          default_node: context.default_node,
+          timeout: timeout,
+          retry_count: retry_count,
+          retry_delay: retry_delay,
+          max_retry_delay: max_retry_delay,
+          retry_writes: retry_writes
+        )
+      end
+
+      # Resolves authentication type and credentials.
+      #
+      # @param user [Models::User] user from config
+      # @param env_config [Hash] environment configuration
+      # @return [Array] [auth_type, token_id, token_secret, username, password]
+      def resolve_auth(user, env_config)
+        # ENV token auth takes precedence
+        if env_config[:token_id] && env_config[:token_secret]
+          return [:token, env_config[:token_id], env_config[:token_secret], nil, nil]
+        end
+
+        # ENV password auth
+        if env_config[:username] && env_config[:password]
+          return [:password, nil, nil, env_config[:username], env_config[:password]]
+        end
+
+        # Fall back to user from config
+        if user.token_auth?
+          [:token, user.token_id, user.token_secret, nil, nil]
+        else
+          [:password, nil, nil, user.username, user.password]
+        end
+      end
+    end
+  end
+end

data/lib/pvectl/config/service.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Config
+    # Facade for configuration management operations.
+    #
+    # Service coordinates Provider, Store, and Wizard to provide a unified
+    # interface for loading, modifying, and saving configuration. It handles
+    # the complete lifecycle of configuration management.
+    #
+    # @example Loading configuration
+    #   service = Service.new
+    #   service.load(config: "~/.pvectl/config", context: "production")
+    #   puts service.current_config.server
+    #
+    # @example Switching contexts
+    #   service.load(config: path)
+    #   service.use_context("development")
+    #
+    # @example Listing contexts
+    #   service.contexts.each do |ctx|
+    #     puts ctx.name
+    #   end
+    #
+    class Service
+      # Default path for configuration file
+      DEFAULT_CONFIG_PATH = File.expand_path("~/.pvectl/config").freeze
+
+      # @return [String] path to loaded configuration file
+      attr_reader :config_path
+
+      # @return [Hash] raw configuration hash from file
+      attr_reader :raw_config
+
+      # @return [String] name of the current context
+      attr_reader :current_context_name
+
+      # Creates a new Service instance.
+      #
+      # @param provider [Provider, nil] configuration provider (default: new Provider)
+      # @param store [Store, nil] configuration store (default: new Store)
+      # @param wizard [Wizard, nil] configuration wizard (default: nil, created on demand)
+      def initialize(provider: nil, store: nil, wizard: nil)
+        @provider = provider || Provider.new
+        @store = store || Store.new
+        @wizard = wizard
+        @loaded = false
+      end
+
+      # Loads configuration from file and CLI options.
+      #
+      # Determines the configuration path from CLI options, environment,
+      # or default location. Warns if file permissions are insecure.
+      #
+      # @param cli_options [Hash] CLI options (:config, :context)
+      # @return [Service] self for chaining
+      # @raise [ConfigNotFoundError] if config file not found and wizard not available
+      # @raise [InvalidConfigError] if config file contains invalid YAML
+      def load(cli_options = {})
+        @config_path = resolve_config_path(cli_options)
+
+        unless @provider.file_exists?(@config_path)
+          raise ConfigNotFoundError, "Configuration file not found: #{@config_path}"
+        end
+
+        warn_insecure_permissions if @provider.insecure_permissions?(@config_path)
+
+        @raw_config = @provider.load_file(@config_path)
+        @current_context_name = @provider.resolve_context_name(
+          cli_options: cli_options,
+          file_config: @raw_config
+        )
+        @resolved_config = nil # Reset cached resolved config
+        @loaded = true
+
+        self
+      end
+
+      # Returns the current resolved configuration.
+      #
+      # @return [Models::ResolvedConfig] resolved configuration
+      # @raise [ConfigError] if configuration not loaded
+      def current_config
+        raise ConfigError, "Configuration not loaded. Call #load first." unless @loaded
+
+        @resolved_config ||= @provider.resolve(
+          config_path: @config_path,
+          cli_options: { context: @current_context_name }
+        )
+      end
+
+      # Returns all contexts from the configuration.
+      #
+      # @return [Array<Models::Context>] list of context models
+      def contexts
+        (@raw_config["contexts"] || []).map do |ctx_hash|
+          Models::Context.from_hash(ctx_hash)
+        end
+      end
+
+      # Returns a specific context by name.
+      #
+      # @param name [String] context name
+      # @return [Models::Context, nil] context or nil if not found
+      def context(name)
+        contexts.find { |ctx| ctx.name == name }
+      end
+
+      # Switches to a different context.
+      #
+      # Updates both the in-memory state and the configuration file.
+      #
+      # @param context_name [String] name of context to switch to
+      # @return [void]
+      # @raise [ContextNotFoundError] if context not found
+      def use_context(context_name)
+        unless context(context_name)
+          available = contexts.map(&:name).join(", ")
+          raise ContextNotFoundError, "Context '#{context_name}' not found. Available: #{available}"
+        end
+
+        @store.update_current_context(@config_path, context_name)
+        @current_context_name = context_name
+        @resolved_config = nil # Reset cached config
+        @raw_config["current-context"] = context_name
+      end
+
+      # Creates or updates a context.
+      #
+      # @param name [String] context name
+      # @param cluster [String] cluster reference
+      # @param user [String] user reference
+      # @param default_node [String, nil] optional default node
+      # @return [Models::Context] the new or updated context
+      def set_context(name:, cluster:, user:, default_node: nil)
+        new_context = Models::Context.new(
+          name: name,
+          cluster_ref: cluster,
+          user_ref: user,
+          default_node: default_node
+        )
+
+        @store.upsert_context(@config_path, new_context)
+
+        # Update in-memory config
+        refresh_raw_config
+
+        new_context
+      end
+
+      # Returns all clusters from the configuration.
+      #
+      # @return [Array<Models::Cluster>] list of cluster models
+      def clusters
+        (@raw_config["clusters"] || []).map do |cluster_hash|
+          Models::Cluster.from_hash(cluster_hash)
+        end
+      end
+
+      # Returns a specific cluster by name.
+      #
+      # @param name [String] cluster name
+      # @return [Models::Cluster, nil] cluster or nil if not found
+      def cluster(name)
+        clusters.find { |c| c.name == name }
+      end
+
+      # Creates or updates a cluster.
+      #
+      # @param name [String] cluster name
+      # @param server [String] Proxmox server URL
+      # @param verify_ssl [Boolean] whether to verify SSL (default: true)
+      # @param certificate_authority [String, nil] path to CA certificate
+      # @return [Models::Cluster] the new or updated cluster
+      def set_cluster(name:, server:, verify_ssl: true, certificate_authority: nil)
+        new_cluster = Models::Cluster.new(
+          name: name,
+          server: server,
+          verify_ssl: verify_ssl,
+          certificate_authority: certificate_authority
+        )
+
+        @store.upsert_cluster(@config_path, new_cluster)
+
+        # Update in-memory config
+        refresh_raw_config
+
+        new_cluster
+      end
+
+      # Returns all users from the configuration.
+      #
+      # @return [Array<Models::User>] list of user models
+      def users
+        (@raw_config["users"] || []).map do |user_hash|
+          Models::User.from_hash(user_hash)
+        end
+      end
+
+      # Returns a specific user by name.
+      #
+      # @param name [String] user name
+      # @return [Models::User, nil] user or nil if not found
+      def user(name)
+        users.find { |u| u.name == name }
+      end
+
+      # Creates or updates user credentials.
+      #
+      # @param name [String] user name
+      # @param token_id [String, nil] API token ID
+      # @param token_secret [String, nil] API token secret
+      # @param username [String, nil] username for password auth
+      # @param password [String, nil] password for password auth
+      # @return [Models::User] the new or updated user
+      def set_credentials(name:, token_id: nil, token_secret: nil, username: nil, password: nil)
+        new_user = Models::User.new(
+          name: name,
+          token_id: token_id,
+          token_secret: token_secret,
+          username: username,
+          password: password
+        )
+
+        @store.upsert_user(@config_path, new_user)
+
+        # Update in-memory config
+        refresh_raw_config
+
+        new_user
+      end
+
+      # Returns configuration with secrets masked for display.
+      #
+      # @return [Hash] configuration with masked secrets
+      def masked_config
+        config = deep_copy(@raw_config)
+
+        (config["users"] || []).each do |user|
+          user_data = user["user"] || {}
+          user_data["token-secret"] = "********" if user_data["token-secret"]
+          user_data["password"] = "********" if user_data["password"]
+        end
+
+        config
+      end
+
+      # Saves the current configuration to file.
+      #
+      # @return [void]
+      def save
+        @store.save(@config_path, @raw_config)
+      end
+
+      private
+
+      # Resolves the configuration file path.
+      #
+      # Priority: CLI option > ENV > default
+      #
+      # @param cli_options [Hash] CLI options
+      # @return [String] resolved path
+      def resolve_config_path(cli_options)
+        cli_options[:config] ||
+          ENV["PVECTL_CONFIG"] ||
+          DEFAULT_CONFIG_PATH
+      end
+
+      # Outputs a warning about insecure file permissions.
+      #
+      # @return [void]
+      def warn_insecure_permissions
+        $stderr.puts "Warning: Configuration file has insecure permissions. " \
+                     "Consider running: chmod 600 #{@config_path}"
+      end
+
+      # Refreshes the raw configuration from disk.
+      #
+      # @return [void]
+      def refresh_raw_config
+        @raw_config = @provider.load_file(@config_path)
+      end
+
+      # Creates a deep copy of a hash.
+      #
+      # @param obj [Object] object to copy
+      # @return [Object] deep copy
+      def deep_copy(obj)
+        case obj
+        when Hash
+          obj.transform_values { |v| deep_copy(v) }
+        when Array
+          obj.map { |v| deep_copy(v) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end